Frames an animation can call by name

An image asset in explicit mode cuts its sheet into cells that each carry a
RegionName, and an animation on it can list those names -- block1 block2 block3
block4 -- instead of listing 0 1 2 3. The point is that a named list survives the
sheet being re-cut or re-ordered, which a numbered one does not.

The engine has played these correctly for as long as they have existed.
ImageFrameProviderCore branches on the mode in all four places that matter, and
the runtime path from validate through play and update to the frame area is
mode-aware throughout. Only AUTHORING was broken, and by one character:
AnimationAsset_ScriptBinding.h formatted a StringTableEntry -- a const char* --
through "%d", so getNamedAnimationFrames returned a row of pointer addresses.
Nothing that asked an animation for its named frames could recover them, so the
Asset Manager refused such an asset twice over: AssetInspector sent it to the
stock inspector, and AssetAnimationStage::canEdit denied it a palette and a
timeline. Both refusals carried comments explaining that the API did not round
trip, and both were right.

NAMED CELLS MODE IS NO LONGER A FLAG ANYBODY SETS. The field, its setter, its
write function and the member are gone; getNamedCellsMode() is a live read of
mImageAsset->getExplicitMode(). The image already held the only honest answer,
and a stored copy could disagree with it the moment that image was re-cut -- and
did worse than that, since a person could set the flag true on an image with no
names at all and get an animation with no frames and no explanation. Nothing has
to keep the two in step now because there is only one of them. The refresh
cascade already reaches here: setExplicitMode ends in refreshAsset,
AssetManager::updateAssetDependencies has the edge from the animation's Image
field, and the drain loop is index-based over a growing vector, so the dependent
animation is dispatched in the same drain that dispatched the image.

The whole editor stays in INDEX space, and that is what kept this small. The
palette shows cell N, the timeline holds cell N, a drag carries cell N, the
range dialog builds "28 29 30"; only loading and committing know that names
exist. Every gesture, the caret arithmetic, the hold detection and the undo
transaction are unchanged.

The one thing index space cannot carry is a name whose cell has been deleted. It
resolves to no index, and EVERY such name resolves to the same -1, so a list
round-tripped through indices would come back from a single edit with two broken
frames merged into one and the other silently committed away. So the timeline
keeps a parallel mSlotNames, always exactly the size of mSlots: mSlots stays the
drawing truth and mSlotNames the authoring truth. setFrames takes indices and
derives names, setNamedFrames takes names and derives indices, and both always
fill both -- which is why appendFrame, insertFrameAtPoint and the range dialog
needed no changes at all. A missing frame draws as an outlined empty cell in the
theme's error color with the name it could not find under it, in the same ink,
and says so again in its tooltip and in the inspector's warning line. It is kept
rather than dropped because dropping it is a deletion the user never asked for
and could not have seen happen.

Cells label themselves in both grids now, so the payoff is visible where the
work is done. That is one virtual on the shared base, so the palette and the
timeline cannot label the same cell differently -- which would make dragging
between them a guess. Long names clip with an ellipsis and the full text is in
the tooltip; the clip measures and draws the same string rather than pairing
getStrNWidth with dglDrawTextN, whose counts are bytes and UTF16 units
respectively and disagree the moment a name is not ASCII.

EVERY EXPLICIT CELL NOW HAS A NAME, which is the invariant the rest rests on. A
cell stored without one is named Frame<N>, seeded at its own index and walked
past anything already taken -- not hypothetical, since deleting a cell from the
middle renumbers every one after it. It happens in calculateExplicitMode, the
one funnel every path ends in, because the TAML read pushes straight into
mExplicitFrames and never goes near addExplicitCell. What stood there before was
a "repair" in four places that could not have worked: it read dSscanf FROM the
empty name INTO a U32 passed by value where a pointer was required, and never
assigned a name to anything. Its guard never fired either -- it compared a
console or TAML buffer against StringTable->EmptyString by POINTER, and neither
is ever interned. The image editor's Add Cell button now asks the engine for the
name instead of building "Frame" @ index itself with no uniqueness check, which
is how adding a cell after deleting one from the middle produced a duplicate
that the rename box beside it would have refused.

Switching an image between explicit and cell mode converts the animations on it,
so the switch is a decision rather than a commitment. Both lists are kept in
memory and only the one in use is written, and the conversion runs from
onAssetRefresh, setImage and initializeAsset -- NOT from validateFrames, which
is where it obviously belongs and where it would have destroyed data. That is
called from inside both frame setters, so setAnimationFrames("") -- what the
editor sends when the timeline is emptied, and what copyFieldsFrom sends on
every single copy -- would have seen an empty active list beside a full one and
put the frames the user had just cleared straight back. validateFrames stays a
pure derivation that touches neither specified list. initializeAsset is new
here: settling this after the whole file is read is what makes the result
independent of TAML field order, which mattered as soon as anything depended on
Image and a frame list together.

Gating the write on the mode is what closes the round trip. Both lists used to
be written whenever they had content, and the named one is applied last and used
to force named mode on -- so an animation given numbered frames after ever
having had named ones came back from its own file named. That in turn made an
older landmine reachable: onTamlCustomWrite gated the Cells node on explicit
mode, so saving an image with the mode off deleted every cell in the file and
with them the only thing that could ever resolve those names again. The cells
are authored data that outlive the mode -- copyAssetStateTo says so in as many
words -- so they are written whenever there are any. Which means the file has to
state the mode out loud, because the read infers explicit mode from the presence
of a Cells node and must keep doing so for every file written before this. A
file that states it is believed; only a file that says nothing is inferred from.

Engine defects fixed on the way, all reachable before any of this:

- getExplicitCellOffset returned NULL from a Vector2-returning function when not
  in explicit mode, which selects Vector2(const char*), which calls setString on
  a null pointer and dereferences it. The image editor's swap-cells path reaches
  it.
- all four getExplicitCell accessors indexed with Vector<T>::at, which takes a
  U32 and only asserts -- so it is unchecked in release and at(-1) was a read at
  four billion. A failed name lookup is exactly what -1 means around here.
- getExplicitCellName and getExplicitCellIndex refused to answer while explicit
  mode was off, which is precisely when a name has to be translated back into an
  index. The guards are off those two; the four mutators keep theirs.
- getCellByName's empty-name guard was the same pointer comparison as above, so
  an empty name matched the first frame of any image whose cells are unnamed.
- ImageFrameProviderCore::mUsingNamedFrame and mNamedImageFrame were never
  initialized by the constructor and never cleared by clearAssets, and
  validRender reads the first on the first frame of every static sprite -- an
  indeterminate true then dereferences an equally indeterminate name.
- getNamedAnimationFrames sized its return buffer at a fixed 4096 that suits a
  list of integers. A region name has no length limit and dSprintf truncates in
  silence, so a long animation would have lost its tail and said nothing. Both
  it and getMissingFrames measure first.
- mValidatedNameFrames was missing its VECTOR_SET_ASSOCIATION, and the dead
  mAnimationIntegration field is gone.

Two new bindings exist to stop script having to branch. getFrameCount answers in
whichever space the animation uses; getAnimationFrameCount refuses in named mode
and returns -1, which read as "fewer than one" to Keep Frame Rate and as "-1
frames" on the inspector's info line. getMissingFrames returns the names no cell
answers to, which is cheaper and more honest than N console calls per refresh.

animationFrameConversionTests and imageAssetCellNameTests cover the arithmetic
through the statics, because building a real explicit cell needs a bitmap and a
unit test has no GL context to load one into: the round trip, a hold surviving
it, everything that fails to resolve in either direction, and the naming search
including the collision walk and the case fold. AnimationAssetCarriesNamedFrames
lost its mode assertion with the field and gained a sibling asserting that BOTH
lists survive a copy, which is what makes the mode switch reversible.
animationFrameValidation carries the engine half -- most valuably that
getNamedAnimationFrames returns four names and not four numbers -- plus the mode
switch, the auto-naming, and the file keeping its cells with the mode off.
assetAnimationTimeline drives the editor half through to reading the saved file
back. The shot harness gains the two pictures that only a picture settles:
whether a name reads at 48 pixels, and whether a missing frame is findable.

The toybox 1234 image and 1234Animation are the demo pair, and the only named
assets in the tree.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014Xh3XULt9PtdCtsaYHGnYE

Author: greenfire27

cmake/EngineSources.cmake

@@ -343,6 +343,7 @@ set(TORQUE_ENGINE_SOURCES
     # ---- testing ----
     ${TORQUE_SRC}/testing/unitTesting.cc
     # ---- testing/tests ----
+    ${TORQUE_SRC}/testing/tests/animationFrameConversionTests.cc
     ${TORQUE_SRC}/testing/tests/assetStateCopyTests.cc
     ${TORQUE_SRC}/testing/tests/bitmapFontParseTests.cc
     ${TORQUE_SRC}/testing/tests/guiControlReparentTests.cc
@@ -355,6 +356,7 @@ set(TORQUE_ENGINE_SOURCES
     ${TORQUE_SRC}/testing/tests/guiTextEditTests.cc
     ${TORQUE_SRC}/testing/tests/guiTextWrapTests.cc
     ${TORQUE_SRC}/testing/tests/guiTreeRowLayoutTests.cc
+    ${TORQUE_SRC}/testing/tests/imageAssetCellNameTests.cc
     ${TORQUE_SRC}/testing/tests/namespaceLinkTests.cc
     ${TORQUE_SRC}/testing/tests/platformFileIoTests.cc
     ${TORQUE_SRC}/testing/tests/platformMemoryTests.cc

editor/AssetAdmin/Animation/AssetAnimationStage.cs

@@ -67,7 +67,7 @@
 
 function AssetAnimationStage::retainFor(%this, %animationAssetId)
 {
-	if(%animationAssetId $= "" || !%this.canEdit(%animationAssetId))
+	if(%animationAssetId $= "" || !AssetDatabase.isDeclaredAsset(%animationAssetId))
 	{
 		%this.teardown();
 		return false;
@@ -76,24 +76,42 @@
 	return true;
 }
 
-// Named cells are out of scope for now, and the reason is not squeamishness: the
-// engine's named-frame API does not round-trip. Its getter formats a string
-// through %d, and the field joins with commas while the setter splits on
-// whitespace, so a named list does not survive its own TAML file. Rather than
-// build a timeline on top of that, such an asset keeps the plain inspector and
-// the old single-sprite preview, which have always worked for it.
-function AssetAnimationStage::canEdit(%this, %animationAssetId)
+// Whether the animation on show addresses its frames by name.
+//
+// Asked of the asset, which asks the image: an image in explicit mode cuts itself
+// into named cells, so an animation on it lists names. Nothing here sets it, and
+// there is no flag to set -- changing the image, or that image's explicit mode,
+// is what changes the answer.
+//
+// The whole editor stays in INDEX space either way. The palette shows cell N, the
+// timeline holds cell N, a drag carries cell N; only loading and committing know
+// about names at all. What that buys is that every gesture, the range dialog, the
+// caret arithmetic and the hold detection are written once.
+function AssetAnimationStage::namedMode(%this)
+{
+	return isObject(%this.animationAsset) && %this.animationAsset.getNamedCellsMode();
+}
+
+// Point the timeline at the asset's frames, in whichever space they are kept.
+//
+// One method because there were three call sites that each did it slightly
+// differently -- selection, a refresh, and an inspector commit -- and a fourth
+// spelling of it was how the named case would have been missed.
+function AssetAnimationStage::loadTimeline(%this)
 {
-	%asset = AssetDatabase.acquireAsset(%animationAssetId);
-	if(!isObject(%asset))
+	if(!isObject(%this.timelinePane) || !isObject(%this.animationAsset))
 	{
-		return false;
+		return;
 	}
 
-	%named = %asset.getNamedCellsMode();
-	AssetDatabase.releaseAsset(%animationAssetId);
-
-	return !%named;
+	if(%this.namedMode())
+	{
+		%this.timelinePane.loadNamed(%this.imageAssetId, trim(%this.animationAsset.getNamedAnimationFrames()));
+	}
+	else
+	{
+		%this.timelinePane.load(%this.imageAssetId, trim(%this.animationAsset.getAnimationFrames()));
+	}
 }
 
 function AssetAnimationStage::select(%this, %imageAsset, %animationAsset, %assetId)
@@ -124,7 +142,7 @@
 	%this.imageAssetId = %animationAsset.getImage();
 
 	%this.palettePane.load(%this.imageAssetId);
-	%this.timelinePane.load(%this.imageAssetId, trim(%animationAsset.getAnimationFrames()));
+	%this.loadTimeline();
 
 	%this.admin.transportBarContainer.setVisible(true);
 
@@ -464,14 +482,21 @@ class = "AssetAnimationPalettePane";
 	// for a list it already holds. The same guard shape AssetInspectorPane uses.
 	if(%isAnimation && !%this.committing)
 	{
-		%this.timelinePane.load(%this.imageAssetId, trim(%this.animationAsset.getAnimationFrames()));
+		%this.loadTimeline();
 	}
 
 	// The image may have been re-cut, so the palette's frame count has moved --
 	// and so has what the animation's frames mean.
+	//
+	// It may also have changed explicit mode, which moves the animation between
+	// name space and index space entirely. The asset has already converted its own
+	// list by the time this runs -- that is what AnimationAsset::onAssetRefresh
+	// does -- so the timeline is reloaded here as well, from whichever list is now
+	// the live one.
 	if(%isImage)
 	{
 		%this.palettePane.reload();
+		%this.loadTimeline();
 	}
 
 	%this.resyncPreview();
@@ -558,17 +583,24 @@ class = "AssetAnimationPalettePane";
 // place in the editor that writes the animation's frames.
 //-----------------------------------------------------------------------------
 
-function AssetAnimationStage::commitFrames(%this, %frames)
+function AssetAnimationStage::commitFrames(%this)
 {
-	if(!%this.built || !isObject(%this.animationAsset))
+	if(!%this.built || !isObject(%this.animationAsset) || !isObject(%this.timelinePane))
 	{
 		return;
 	}
 
+	%named = %this.namedMode();
+
 	// How many frames there were, asked of the ASSET rather than of the strip:
 	// the strip already holds the edited list by the time it reports, so it can
 	// no longer say what the animation used to be.
-	%before = %this.animationAsset.getAnimationFrameCount();
+	//
+	// getFrameCount rather than getAnimationFrameCount, because that one refuses
+	// to answer in named mode and returns -1 -- which reads as "fewer than one"
+	// to keepFrameRate below, and would have silently switched that feature off
+	// for every named animation.
+	%before = %this.animationAsset.getFrameCount();
 
 	// Where the preview is, captured BEFORE the write, because the engine
 	// restarts playback in the middle of it: AssetManager::refreshAsset notifies
@@ -586,8 +618,20 @@ class = "AssetAnimationPalettePane";
 	// Guarded because the change comes straight back: every asset setter ends in
 	// refreshAsset, which announces the change and fires onRefresh synchronously,
 	// inside this call.
+	//
+	// The list is asked of the strip in whichever space the asset keeps it. Both
+	// are always available -- the strip fills its index list and its name list
+	// together, whichever one it was given -- so this is a choice of which to hand
+	// over, not a conversion.
 	%this.committing = true;
-	%this.animationAsset.setAnimationFrames(%frames);
+	if(%named)
+	{
+		%this.animationAsset.setNamedAnimationFrames(%this.timelinePane.strip.getNamedFrames());
+	}
+	else
+	{
+		%this.animationAsset.setAnimationFrames(%this.timelinePane.strip.getFrames());
+	}
 	%this.committing = false;
 
 	// Before the slot is forgotten, because this changes the asset a second time
@@ -657,7 +701,7 @@ class = "AssetAnimationPalettePane";
 
 	%this.imageAssetId = %imageAssetId;
 	%this.palettePane.load(%imageAssetId);
-	%this.timelinePane.load(%imageAssetId, trim(%this.animationAsset.getAnimationFrames()));
+	%this.loadTimeline();
 
 	%this.admin.transportBar.refresh();
 }

editor/AssetAdmin/Animation/AssetAnimationTimelinePane.cs

@@ -89,13 +89,25 @@
 	%this.scroller.add(%this.strip);
 }
 
+// The image FIRST in both of these, and that order is load bearing.
+//
+// The strip fills its index list and its name list together, and it can only do
+// that by asking the image what cell N is called or which cell is called N. Given
+// the frames before the image, every name resolves to nothing.
 function AssetAnimationTimelinePane::load(%this, %imageAssetId, %frames)
 {
 	%this.strip.setImageAsset(%imageAssetId);
 	%this.strip.setFrames(%frames);
 	%this.refreshCaption();
 }
 
+function AssetAnimationTimelinePane::loadNamed(%this, %imageAssetId, %names)
+{
+	%this.strip.setImageAsset(%imageAssetId);
+	%this.strip.setNamedFrames(%names);
+	%this.refreshCaption();
+}
+
 function AssetAnimationTimelinePane::setPreviewSprite(%this, %sprite)
 {
 	%this.strip.setPreviewSprite(%sprite);
@@ -119,10 +131,14 @@
 // pane's job, and writing it is the stage's.
 //-----------------------------------------------------------------------------
 
+// The list is no longer handed over here. The stage reads it off the strip in
+// whichever space the asset keeps its frames, and only the stage knows which that
+// is -- passing indices from here meant a named animation was committed as a row
+// of numbers to a setter that refuses them.
 function AssetAnimationTimelinePane::commitFrames(%this)
 {
 	%this.refreshCaption();
-	%this.stage.commitFrames(%this.strip.getFrames());
+	%this.stage.commitFrames();
 }
 
 function AssetAnimationTimelinePane::appendFrame(%this, %frame)
@@ -137,10 +153,20 @@
 	%this.commitFrames();
 }
 
+// Inserted one at a time rather than concatenated onto getFrames() and set back.
+//
+// The round trip through the index list was lossy once frames could be missing: a
+// frame whose cell has been deleted is index -1, and rebuilding the list from
+// indices would have turned every such frame into the same nameless hole. Adding
+// to the end touches nothing that is already there.
 function AssetAnimationTimelinePane::appendFrames(%this, %frames)
 {
-	%existing = %this.strip.getFrames();
-	%this.strip.setFrames(%existing $= "" ? %frames : (%existing SPC %frames));
+	%count = getWordCount(%frames);
+	for(%i = 0; %i < %count; %i++)
+	{
+		%this.strip.insertFrame(%this.strip.getCellCount(), getWord(%frames, %i));
+	}
+
 	%this.commitFrames();
 }
 

editor/AssetAdmin/AssetInspector.cs

@@ -737,21 +737,14 @@ class = "DuplicateAssetDialog";
 	%this.titlebar.setText("Animation Asset:" SPC %animationAsset.AssetName);
 	%this.beginDocument(%animationAsset);
 
-	// Named cells still fall back to the generic inspector.
+	// Named cells come here too now.
 	//
-	// The reason they used to is now gone: NamedAnimationFrames is a
-	// TypeStringTableEntryVector, whose getter joins with commas, and
-	// setNamedAnimationFrames split on whitespace alone -- so a named list did not
-	// survive its own TAML file, and a pane built on it would have quietly lost
-	// work. The setter accepts commas now (AnimationAsset.cc), so a named-cells
-	// pane is buildable. It is simply not built yet, which is a job of its own
-	// rather than a hazard.
-	if(%animationAsset.getNamedCellsMode())
-	{
-		%this.inspectStock(%animationAsset);
-		return;
-	}
-
+	// They used to fall through to the generic inspector, and there were two good
+	// reasons at the time: setNamedAnimationFrames split on whitespace while the
+	// field joined with commas, so a named list did not survive its own TAML file;
+	// and getNamedAnimationFrames formatted a StringTableEntry through %d, so what
+	// came back was a row of pointers. Both are fixed, and the pane reads a named
+	// animation the same way it reads a numbered one.
 	%this.chooseInspector("Animation");
 	%this.animationPane.bind(%animationAsset, %assetID);
 }

editor/AssetAdmin/ImageEditor/AssetImageFrameEditTool.cs

@@ -141,18 +141,29 @@
 	%this.startListening(%row);
 }
 
+// The name is the engine's to choose, and then read back.
+//
+// This used to build "Frame" @ %index itself, with no uniqueness check at all --
+// so adding a cell after deleting one from the middle produced a second cell
+// with a name that already existed, which onCellNameChange right below would have
+// refused had a person typed it. The engine names an unnamed cell on the way
+// through calculateExplicitMode, walking past any name already taken, and that is
+// now the only place the rule lives.
 function AssetImageFrameEditTool::addNewCell(%this)
 {
 	%index = %this.asset.getExplicitCellCount();
-	%name = "Frame" @ %index;
 	%x = 0;
 	%y = 0;
 	%width = %this.asset.getImageWidth();
 	%height = %this.asset.getImageHeight();
 
 	%this.rowChain.callOnChildrenNoRecurse("updateCellCount", %index + 1);
 
-	%this.asset.addExplicitCell(%x, %y, %width, %height, %name);
+	// addExplicitCell refreshes the asset before it returns, so the name it picked
+	// is there to be read on the next line.
+	%this.asset.addExplicitCell(%x, %y, %width, %height, "");
+	%name = %this.asset.getExplicitCellName(%index);
+
 	%this.addImageFrameRow(%name, %x SPC %y, %width, %height, %index);
 }
 

editor/AssetAdmin/Inspector/AssetAnimationInspectorPane.cs

@@ -30,11 +30,14 @@
 // the one that is only a box cannot say which frame 67 is.
 //
 // Also absent, each for a checkable reason:
-//   NamedAnimationFrames, NamedCellsMode  v1 is numeric, and the engine's named
-//                                         frame API does not round-trip through
-//                                         its own file -- so this pane is never
-//                                         shown for such an asset rather than
-//                                         offering a switch into it
+//   NamedAnimationFrames                  the same field as AnimationFrames, in
+//                                         name space, and the timeline owns that
+//                                         one too
+//   NamedCellsMode                        not a field at all any more. Whether an
+//                                         animation names its frames is read from
+//                                         the image -- explicit mode means named
+//                                         cells -- so a switch here would be a
+//                                         second, disagreeing answer
 //   AssetInternal, AssetPrivate           they exist to keep an asset out of the
 //                                         editor
 //   asset id, asset file                  the module and the name are on show,
@@ -206,7 +209,10 @@
 // answer separately: how long, how many, and therefore how fast.
 function AssetAnimationInspectorPane::describeAnimation(%this, %asset)
 {
-	%count = %asset.getAnimationFrameCount();
+	// getFrameCount, not getAnimationFrameCount: that one refuses to answer for an
+	// animation using named cells and returns -1, which read as "-1 frames" on
+	// this very line.
+	%count = %asset.getFrameCount();
 	%time = %asset.getAnimationTime();
 
 	%line = %count SPC ((%count == 1) ? "frame," : "frames,") SPC %time SPC "s";
@@ -253,18 +259,35 @@
 		return "The image asset" SPC %imageId SPC "did not load, so there is nothing to play.";
 	}
 
+	// The two spaces fail differently, so they are reported differently.
+	//
+	// A named frame that no cell answers to is simply not drawn, and the timeline
+	// keeps it as an outlined gap -- so the useful thing to say is WHICH names,
+	// because the fix is either to put the cell back or to take the frame out.
+	if(%asset.getNamedCellsMode())
+	{
+		%missing = trim(%asset.getMissingFrames());
+		if(%missing !$= "")
+		{
+			%plural = (getWordCount(%missing) == 1);
+			return (%plural ? "The frame" : "The frames") SPC "\"" @ %missing @ "\"" SPC
+				(%plural ? "names a cell" : "name cells") SPC "the image no longer has, so" SPC
+				(%plural ? "it draws" : "they draw") SPC "nothing. Put the cell back on the " @
+				"Explicit Frames tab, or take the frame out of the timeline.";
+		}
+	}
+	// A numbered frame out of range is CLAMPED to the last one rather than
+	// dropped, so the animation keeps playing and quietly shows the wrong art.
 	// Specified against validated is the only comparison script can make, and it
-	// is exactly the right one: validateNumericalFrames CLAMPS an out-of-range
-	// frame to the last one rather than dropping it, so the animation keeps
-	// playing and quietly shows the wrong art.
-	if(trim(%asset.getAnimationFrames()) !$= trim(%asset.getAnimationFrames(true)))
+	// is exactly the right one.
+	else if(trim(%asset.getAnimationFrames()) !$= trim(%asset.getAnimationFrames(true)))
 	{
 		return "Some frames are outside the image's" SPC %image.getFrameCount() SPC
 			"and are being clamped to the nearest one. The timeline shows what was asked for; " @
 			"the preview shows what is being drawn.";
 	}
 
-	if(%asset.getAnimationFrameCount() == 0)
+	if(%asset.getFrameCount() == 0)
 	{
 		return "This animation has no frames yet. Drag one in from the palette, or use Frame Range.";
 	}

editor/EditorCore/Themes/BaseTheme/BaseTheme.cs

@@ -1931,6 +1931,14 @@
 		fontColorHL = %this.color4;
 		fontColorSL = %this.color5;
 
+		// Errors, in the sense the console profile uses this slot for. The
+		// timeline outlines a frame naming a cell the image no longer has, and this
+		// is the color of that outline and of its label. The four FILL colors are
+		// all spoken for -- background, hover, selected, and about-to-be-discarded
+		// during a drag -- which is why a missing frame is a border rather than a
+		// wash.
+		fontColorNA = "255 0 0 255";
+
 		// The Delete key only reaches a control that can hold focus, and the
 		// timeline's whole keyboard depends on it.
 		canKeyFocus = true;