#About validator rules
The validator checks a mod in LumaLink (lumalink check, build and pack) and again in the game, when it
imports the mod and at each start. Both report the same codes with the same words, in the player's language.
- An Error turns the mod off, or stops LumaLink.
- A Note only tells you something. The mod stays on.
In the words, {mod}, {file}, {entry} and the other names in braces are filled with the finding's own
values. A {why}, {what} or {kind} is itself one of the Reasons below.
To print a code's words and what to do, run lumalink explain CODE, for example lumalink explain L505.
#The container (L100)
The .luma file as a ZIP archive.
| Code | Level | Words |
|---|---|---|
| L100 | Error | {file} is not a .luma: {found}. |
| L101 | Error | {file}: {found}. |
| L102 | Error | {file}: the entry "{entry}" has a name that is not allowed: {why}. |
| L103 | Error | {file}: "{entry}" clashes with "{other}" (the same name on some systems, or a file where a folder is). |
| L104 | Error | {file}: "{entry}" is {what}; a .luma holds only files and folders. |
| L105 | Error | {file}: {what} is {found}; the most allowed is {expected}. |
| L106 | Error | {file}: "{entry}": {why}. |
| L107 | Error | {mod}: "{entry}" is not part of a .luma (the top level holds luma.json, layers/, code/, media/, saves/, kit/, source/ and tests/). |
| L108 | Note | {file} was made with a tool that writes backslashes between folders; they are read as /. lumalink pack writes the standard form |
#luma.json (L200)
The manifest. For every key, see luma.json.
| Code | Level | Words |
|---|---|---|
| L200 | Error | {file} has no luma.json. |
| L201 | Error | {mod}: luma.json line {line}: {found}. |
| L202 | Error | {mod}: luma.json line {line}: "{key}" is not a key that can be here. |
| L203 | Error | {mod}: luma.json line {line}: "{key}" is missing. |
| L204 | Error | {mod}: luma.json line {line}: "{key}" is {found}; it must be {expected}. |
| L205 | Error | {mod} was made for a newer Nebula (format {found}); this one reads format {expected} and older. |
| L206 | Error | {mod}: the id "{found}" may only use lowercase letters, digits, - and ., start with a letter, and be 3 to 64 long; its part before the first . may not be a name Windows keeps (con, prn, aux, nul, com1 to com9, lpt1 to lpt9). |
| L207 | Error | {mod} is for {found}, not Super Mario Galaxy. |
| L208 | Note | {mod} is made for {expected}; your game is {found}, so it is off. |
| L209 | Error | {mod}: {key} names "{entry}": {why}. |
| L210 | Error | {mod}: option "{key}": {why}. |
| L211 | Error | {mod}: permission "{key}": {why}. |
| L212 | Error | {mod}: the load order cannot be met: {found}. |
| L213 | Error | {mod}: takes_over "{found}": {why}. |
| L214 | Error | {mod}: luma.json line {line}: "{found}" is not a language of the game. |
| L215 | Error | {mod}: "{entry}" is in media/ but luma.json does not name it. |
| L216 | Error | {mod}: save "{entry}": {why}. |
| L217 | Error | {mod}: "{entry}" is in saves/ but luma.json does not name it. |
| L218 | Note | {mod} asks for the "{permission}" permission, but no code of it imports a service that needs it. |
| L219 | Note | {mod}: permission "{key}" is a test permission: only a test run provides it. |
| L220 | Error | {mod}: luma.json line {line}: "{key}" is the previous engine's; write {expected}. |
| L221 | Note | {mod}: luma.json line {line}: "{key}" is the previous engine's, read for now; a later game will not read it. Write it in the mod format's own keys. |
#Layers and files (L300)
The content in layers/.
| Code | Level | Words |
|---|---|---|
| L300 | Error | {mod}: layer "{layer}": {why}. |
| L301 | Error | {mod}: layer "{layer}": {why}. |
| L302 | Error | {mod}: {file}: the game has no "{found}", and this kind of file cannot be new. |
| L303 | Error | {mod}: {file} replaces "{found}", which has rows: change it with a patch by key instead. |
| L304 | Error | {mod}: {file}: a {kind} cannot stand in for "{found}" ({expected}). |
| L305 | Note | {mod} and {other} both replace "{found}"; {winner}'s is used (it is higher in the list). |
| L306 | Error | {mod}: "{entry}" is not in files/, patches/, merge/ or assets/, nor a .png or .dds in textures/. |
| L307 | Error | {mod}: layer "{layer}" is chosen by the mod's code, which does not run on {platform}. |
| L308 | Error | {mod}: {file}: hides "{found}", which is no model of the game. |
| L309 | Error | {mod}: "{entry}" is in merge/, which adds only to tables (.json), messages (.json), particles (.jpc, .jpc.json) and ray tracing rows (NebulaData/Rt*.tsv). |
#Table patches (L400)
Patches of the game's tables. For the keys, see Table keys.
| Code | Level | Words |
|---|---|---|
| L400 | Error | {mod}: {file} line {line}: {found}. |
| L401 | Error | {mod}: {file}: rows of "{target}" are keyed by {expected}, not {found}. |
| L402 | Error | {mod}: {file} line {line}: {why}. |
| L403 | Error | {mod}: {file} line {line}: {why}. |
| L404 | Note | {mod} and {other} both change "{target}" row {row}: {what}; {winner}'s change is used (it is higher in the list). |
| L405 | Error | {mod}: {file} changes "{target}" of {other}; add {other} to needs first. |
| L406 | Error | {mod}: {file} line {line}: {why}. |
| L407 | Note | {mod}: {file} line {line}: the selector matched no row of "{target}". |
#Code (L500)
The mod's built libraries in code/.
| Code | Level | Words |
|---|---|---|
| L500 | Error | {mod}: {why}. |
| L501 | Error | {mod}: code for "{found}": {why}. |
| L502 | Error | {mod}: {file} is not a {expected} library: it is {found}. |
| L503 | Error | {mod}: {file} does not export luma_mod. |
| L504 | Error | {mod}: {file} needs {library} ({found}); a mod's own library may need nothing from the system. |
| L505 | Error | {mod}: {file}: the game has no {kind}. |
| L506 | Error | {mod} uses {service} without asking for the "{permission}" permission. |
| L507 | Note | {mod} has no code for {platform}, so it is off there. |
| L508 | Error | {mod}: {file} needs LumaCore {found}; this game has {expected}. |
| L509 | Error | {mod}: {file}: {why}. |
| L510 | Note | {mod}: {file} needs {library} ({found}). |
| L511 | Error | {mod}: {file} cannot run on iOS: {why}. |
| L512 | Error | {mod}: {file}: luma_mod cannot be used: {why}. |
| L513 | Error | {mod}: {file}: {mod} is built with LumaScript runtime layout {version} and {other}, whose {name} it calls, with layout {value}. Rebuild the older one with a current LumaLink, or update it. |
#Data for a library (L700)
A mod's data for a library mod, in kit/.
| Code | Level | Words |
|---|---|---|
| L700 | Error | {mod}: {why}. |
| L701 | Error | {mod}: {file} line {line}: {module}: {text}. |
| L702 | Error | {mod} needs {module} data version {found}; the installed {library} gives: {expected}. Update {library}, or install a version of {mod} made for it. |
#Preparing, loading and starting (L800)
What the game finds when it prepares, loads and starts the mods.
| Code | Level | Words |
|---|---|---|
| L800 | Error | {mod} needs {other} {expected}: {found}. |
| L801 | Error | {mod} cannot be on with {other}: {why}. |
| L802 | Error | {mod}: another installed mod, {other}, has the id "{found}". |
| L803 | Error | {mod} needs Nebula {expected}; this is {found}. |
| L804 | Error | {mod}: {file}: {text}. |
| L805 | Error | {mod}: {file} replaces "{found}" ({sig}), which {other} replaces already; only one mod may replace a function. |
| L806 | Error | {mod} needs {feature}, which this device's graphics do not have. |
#Reasons
A finding's {why}, {what} or {kind} is one of these phrases, listed by its key.
#The ZIP archive
| Key | Words |
|---|---|
Zip.BadDirectory |
its zip directory is damaged |
Zip.BadZip64 |
its Zip64 directory is damaged |
Zip.Encrypted |
"{entry}" is encrypted, which a .luma may not be |
Zip.Method |
"{entry}" is packed with method {method}; a .luma may only be stored or deflated |
Zip.MultiDisk |
it spans several disks; a .luma is one file |
Zip.NoEnd |
it has no zip directory at its end |
Zip.TooShort |
it is too short to be a zip file |
Zip.Unreadable |
it cannot be read |
#Unpacking
| Key | Words |
|---|---|
Unpack.Broken |
it cannot be unpacked; its data is damaged |
Unpack.CrcDiffers |
its unpacked data does not match its checksum |
Unpack.Larger |
it unpacks to more than the {expected} bytes it states |
Unpack.Overlap |
its data shares bytes with "{other}" |
Unpack.SizeDiffers |
it unpacks to {found} bytes, not the {expected} it states |
#Limits
| Key | Words |
|---|---|
Limit.Entries |
the number of entries |
Limit.FileSize |
the size of "{entry}" in bytes |
Limit.TotalSize |
the unpacked size in bytes |
#Entry names
| Key | Words |
|---|---|
Name.Absolute |
it starts at the root of a drive or of the system |
Name.Backslash |
it uses a backslash; folders are separated by / |
Name.Class |
class "{found}" |
Name.Combining |
it holds a combining mark or a Hangul jamo, which systems store in different forms |
Name.Control |
it holds a control character |
Name.DotPart |
it has a part that is . or .. |
Name.EmptyPart |
it has an empty part (two / in a row, or / at the end) |
Name.Field |
field "{found}" |
Name.FieldSig |
field "{found}" of type "{sig}" |
Name.FieldUnbound |
field "{found}" a mod can bind ({why}) |
Name.Forbidden |
it holds a character Windows does not allow in names: < > : | ? * or a quotation mark |
Name.Function |
function "{found}" |
Name.FunctionMany |
single function "{found}": the import names no signature and it has several ({has}) |
Name.FunctionSig |
function "{found}" with the signature "{sig}" |
Name.FunctionSigHas |
function "{found}" with the signature "{sig}" (its signatures: {has}) |
Name.Global |
global variable "{found}" |
Name.GlobalSig |
global variable "{found}" of type "{sig}" |
Name.GlobalUnbound |
global variable "{found}" a mod can bind ({why}) |
Name.LeadingAt |
a layer, or a path in files/ or assets/, may not start with @, which names another mod's files |
Name.LocalDiffers |
its name in the zip's directory differs from the name stored with its data |
Name.Method |
virtual function "{found}" with the signature "{sig}" |
Name.MethodHas |
virtual function "{found}" with the signature "{sig}" (its signatures: {has}) |
Name.ModFunction |
function "{found}" of a mod that is on |
Name.NotUtf8 |
it is not written in UTF-8 |
Name.Reserved |
a part is a device name Windows reserves (CON, PRN, AUX, NUL, COM1 to COM9, LPT1 to LPT9 and the like) |
Name.Service |
service "{found}" at version {sig} or a later one with the same major number |
Name.TooLong |
it is longer than 240 bytes |
Name.TrailingDotOrSpace |
a part ends in a dot or a space, which Windows removes |
Name.Type |
type "{found}" |
Name.TypeUnbound |
type "{found}" a mod can bind ({why}) |
#Clashing names
| Key | Words |
|---|---|
Clash.Column |
the column "{column}" |
Clash.Row |
one adds the row and the other removes it |
#Entry kinds
| Key | Words |
|---|---|
Kind.Device |
a device |
Kind.Link |
a link |
#JSON
| Key | Words |
|---|---|
Json.AfterEnd |
"{detail}" comes after the end of the JSON |
Json.BadEscape |
a backslash is followed by something JSON does not allow |
Json.BadNumber |
"{detail}" is not a number JSON allows |
Json.Bom |
it starts with a byte order mark; save it as UTF-8 without one |
Json.Comment |
JSON has no comments |
Json.ControlInString |
a control character ({detail}) is inside a string; write it as an escape |
Json.DuplicateKey |
the key "{detail}" is given twice |
Json.Expected |
"{detail}" was expected here |
Json.KeyNotString |
a key must be text in quotation marks, not "{detail}" |
Json.LeadingZero |
a number starts with 0 |
Json.NotUtf8 |
it is not UTF-8 text |
Json.TooDeep |
lists and objects are nested more than {detail} deep |
Json.TooLarge |
it is larger than 1 MiB |
Json.TrailingComma |
a comma comes before a closing bracket |
Json.Truncated |
the file ends before the JSON does |
Json.Unexpected |
"{detail}" cannot be here |
Json.Unreadable |
it cannot be read |
#Expected values
| Key | Words |
|---|---|
Expect.Array |
a list |
Expect.Bool |
true or false |
Expect.Count |
a list of {min} to {max} items |
Expect.Feature |
a graphics feature the game's renderer lists |
Expect.FeatureName |
a feature name: up to 32 lowercase letters, digits and single _, starting with a letter and not ending in _ |
Expect.Format |
a format version such as 1.0 |
Expect.Host |
a host: a name such as example.com or *.example.com, an IPv4 address, or *, with no port |
Expect.Https |
a link that starts with https:// |
Expect.Id |
an id of 3 to 64 lowercase letters, digits, - and ., starting with a letter |
Expect.Key |
a key of 1 to 64 lowercase letters, digits, -, . and _, starting with a letter |
Expect.Language |
one of the game's languages |
Expect.LibraryName |
a library's file name, without folders, not starting with mod. |
Expect.Line |
one line of {min} to {max} characters |
Expect.ListedPlatform |
a platform listed in code.platforms |
Expect.MaxLength |
a whole number from 1 to 256 |
Expect.ModuleId |
a LumaKit module id such as author.module |
Expect.NotSelf |
the id of another mod |
Expect.Number |
a number |
Expect.Object |
an object |
Expect.Once |
a value that appears only once |
Expect.OptionKind |
one of choice, number, toggle, text or key |
Expect.Platform |
one of windows-x64, windows-arm64, linux-x64, linux-arm64, macos-arm64, macos-x64, android-arm64, android-x64 or ios-arm64 |
Expect.Range |
a version range such as >=1.2.0 or ^1.0 |
Expect.Region |
one of RMGE01, RMGP01 or RMGJ01 |
Expect.SchemaVersion |
a whole number from 1 to 1000000 |
Expect.Spdx |
an SPDX license name such as MIT or CC-BY-4.0 |
Expect.String |
text |
Expect.True |
true |
Expect.Version |
a version such as 1.0.0 |
#Found values
| Key | Words |
|---|---|
Found.Items |
a list of {count} items |
Found.ThisText |
text that does not fit |
#The game
| Key | Words |
|---|---|
Game.Galaxy2 |
Super Mario Galaxy 2 |
#Media
| Key | Words |
|---|---|
Media.IconSize |
the icon must be square, 64 to 1024 pixels on a side |
Media.Missing |
the mod has no such file |
Media.NotInMedia |
the file must be directly in media/ |
Media.NotPicture |
it is not a PNG or JPEG picture |
Media.NotPng |
the icon must be a PNG picture |
Media.PictureSize |
a picture may be at most 4096 pixels on a side |
Media.Unreadable |
the file cannot be read |
#Options
| Key | Words |
|---|---|
Option.DefaultNotAValue |
its default "{value}" is not one of its values |
Option.DefaultOffStep |
its default is not min plus a whole number of steps |
Option.DefaultOutside |
its default is outside min to max |
Option.DefaultTooLong |
its default is longer than max_length or is more than one line |
Option.KeyDefaultUnknown |
its default "{value}" is not a control the game names (a, b, one, two, plus, minus, home, c, z, dpad_up, stick_up, shake, pointer_up and the like) |
Option.MinNotBelowMax |
min must be less than max |
Option.NameOfNoValue |
value_names names "{value}", which is not one of its values |
Option.StepNotPositive |
step must be more than 0 |
Option.TextOfNoOption |
text gives words for it, but luma.json has no such option |
Option.Twice |
two options have this key |
Option.ValueTwice |
the value "{value}" is given twice |
Option.ValueUnnamed |
the value "{value}" has no name in value_names |
#Permissions
| Key | Words |
|---|---|
Perm.HostCount |
net.internet takes 1 to 32 hosts |
Perm.HostTwice |
a host is listed twice (upper and lower case count as the same) |
Perm.HostsOnlyNet |
only net.internet takes hosts |
Perm.NetHosts |
net.internet needs hosts, the servers it may reach |
Perm.NetSplit |
net is two permissions now: write net.local or net.internet |
Perm.NoWhy |
it needs a why that players read |
Perm.RootCount |
roots lists 1 to 8 files |
Perm.RootMissing |
the mod has no file "{entry}" |
Perm.RootNotPem |
the root "{entry}" holds no PEM certificate (-----BEGIN CERTIFICATE-----) |
Perm.RootPath |
the root "{entry}" must be a file in the mod's certs/ folder |
Perm.RootSize |
the root "{entry}" is larger than 64 KiB |
Perm.RootTwice |
the root "{entry}" is listed twice |
Perm.RootsOnlyNet |
only net.local and net.internet take roots |
Perm.Twice |
it is asked for twice |
Perm.Unknown |
this game has no such permission |
#takes_over
| Key | Words |
|---|---|
TakesOver.On |
that mod is installed and on; turn it off first |
TakesOver.Self |
a mod cannot take over itself |
#Saves
| Key | Words |
|---|---|
Save.Checksum |
its checksum does not match (the file was changed or damaged) |
Save.Chunk |
a part of it is damaged |
Save.Encrypted |
it is the encrypted copy a Wii writes to an SD card; give the save file itself |
Save.Length |
the length it states differs from its size |
Save.Missing |
the mod has no such file |
Save.NotInItsFolder |
it must be in its region's folder, such as saves/RMGE01/ |
Save.RegionNotOfMod |
its region is not in game.regions |
Save.Short |
it is too short to be a save |
Save.Table |
its table of parts is damaged |
Save.UnknownRegion |
its region must be RMGE01, RMGP01 or RMGJ01 |
Save.Unreadable |
the file cannot be read |
Save.Version |
it is a save of a version this game does not read |
#Needs
| Key | Words |
|---|---|
Need.Cycle |
each needs the next, in a circle ({chain}), so none of them can start first |
Need.Missing |
it is not installed |
Need.Off |
it is off |
Need.Version |
version {version} is installed |
#Conflicts
| Key | Words |
|---|---|
Conflict.Theirs |
{other} lists this mod in its conflicts |
#Layers
| Key | Words |
|---|---|
Layer.EmptyList |
a list in its when is empty, so it can never apply |
Layer.EmptyWhen |
its when is empty; leave when out for a layer that always applies |
Layer.NoFolder |
it is listed in luma.json, but there is no layers/{layer}/ folder |
Layer.NoSuchOption |
its when names "{value}", which is not an option of this mod |
Layer.NotListed |
there is a folder for it, but luma.json does not list it |
Layer.OptionNotChoosing |
its when names "{value}", a text or key option: the mod reads that itself, and it cannot choose a layer |
Layer.RegionNotOfMod |
its when names the region {value}, which is not in game.regions |
Layer.Twice |
it is listed twice |
Layer.ValueNever |
its when asks the option "{value}" for a value it can never have |
#Patches
| Key | Words |
|---|---|
Patch.AddNoKey |
an added row must give every key column: {detail} |
Patch.ArgsShape |
"args" gives the object's arguments by name: an object of names and whole numbers |
Patch.BytesShape |
"{column}": "bytes" must be an even number of hex digits, with nothing else beside it |
Patch.KeyInGroup |
the key {row} is in {where} already: the game links by it across the zone's layers; give another |
Patch.KeyRepeated |
the game has {count} rows with the key {row}; change them with select |
Patch.KeyShape |
"key" must be a list of 1 to 8 column names |
Patch.KeyValue |
the key "{column}" must be a number or text; "#" is a place, 0 or more |
Patch.NoKey |
it has no "key", the list of the columns that name a row |
Patch.NoPanes |
it has no "panes", the panes of the layout it changes, by name |
Patch.NoRows |
"{detail}" has no rows to patch; replace it as a whole file in files/ |
Patch.NoSuchColumn |
"{target}" has no column "{column}" |
Patch.NoVersion |
it has no "patch": 1 |
Patch.NotArray |
"{detail}" must be a list |
Patch.NotJson |
a patch file's name must end in .json |
Patch.NotObject |
a patch is one JSON object |
Patch.PanesShape |
"panes" must be an object: each pane's name and what changes in it |
Patch.PlaceNotFound |
the table has {count} rows, numbered from 0; there is no row "#" {row} |
Patch.RemoveByPlace |
rows of this table are named by place ("#"), and a remove would move every later row; give the whole table with "rows" |
Patch.RowExists |
a row with the key {row} exists already; change it with set |
Patch.RowNotFound |
no row has the key {row} |
Patch.RowShape |
each added row is an object of column names and values |
Patch.RowsNotByPlace |
"rows" gives a whole table, which only a table named by place ("#") takes; this one is keyed: use set, add and remove |
Patch.SelectShape |
each entry of "select" is an object with only "match" and "values", neither empty |
Patch.SetShape |
each entry of "set" is an object with only "where" and "values", "values" not empty |
Patch.TooLarge |
it is larger than 64 MiB |
Patch.UnknownKey |
"{detail}" is not a key of a patch (patch, key, set, add, remove, select, rows) |
Patch.ValueType |
column "{column}" holds {expected}; {found} does not fit |
Patch.Version |
"patch" is {detail}; this game reads patches of version 1 |
Patch.WhereNotKey |
it must give exactly the key columns, in order: {detail} |
#Patch rows
| Key | Words |
|---|---|
Where.Font |
a font goes in assets/ with a .font.json that names it |
Where.ModelPart |
a model's buffer or image, read only when a .gltf or .glb beside it names it |
Where.Movie |
a movie goes in assets/ as AV1 in WebM or IVF, with a .movie.json that names it |
Where.Music |
a MIDI file goes in assets/ with a .sound.json that makes it a sequence |
Where.Table |
files/ cooks a .json only as .bcsv.json, .bcam.json, a placement table in .arc/jmp/, .layout.json, .anim.json or .model.json; other .json sources go in assets/ |
Where.Texture |
a model's image, read only when a .gltf or .glb beside it names it, or a game texture in textures/ |
#Selectors
| Key | Words |
|---|---|
Select.GlobNotText |
a glob on "{column}" must be text |
Select.MatchKind |
the match on "{column}" must be one of equals, prefix or glob, with one value |
Select.NoSuchColumn |
this file has no column "{column}" |
#Columns
| Key | Words |
|---|---|
Column.Float |
numbers |
Column.Int |
whole numbers from {min} to {max} |
Column.Text |
text |
#Value types
| Key | Words |
|---|---|
Type.Array |
a list |
Type.Bool |
true or false |
Type.Null |
null |
Type.Number |
a number |
Type.Object |
an object |
Type.String |
text |
#Code
| Key | Words |
|---|---|
Code.ExtraMissing |
{expected}, named in code.libraries, is missing |
Code.ExtraWithoutNative |
extra libraries ({found}) need the native permission |
Code.FolderWithoutKey |
there is a code/ folder, but luma.json has no code |
Code.KeyWithoutFolder |
luma.json has code, but there is no code/ folder |
Code.Nested |
a code folder holds files only, not folders |
Code.NoEntryLibrary |
its library {expected} is missing |
Code.NotAFolder |
it must be a folder, not a file |
Code.NotListed |
the folder is there, but code.platforms does not list it |
Code.NotNamed |
this file is neither the mod's library nor named in code.libraries |
Code.UnknownPlatform |
this is not a platform (windows-x64, windows-arm64, linux-x64, linux-arm64, macos-arm64, macos-x64, android-arm64, android-x64, ios-arm64) |
#Libraries
| Key | Words |
|---|---|
Lib.AnyLibrary |
a library it does not name |
Lib.BadElf |
a damaged ELF file |
Lib.BadMachO |
a damaged Mach-O file |
Lib.BadPe |
a damaged PE file |
Lib.CallTell |
"{found}" is a constructor, a destructor or a function with a variable number of arguments, which cannot be called by name |
Lib.Encrypted |
it is encrypted (LC_ENCRYPTION_INFO_64), so the device cannot sign it again |
Lib.HookOnConstructor |
"{found}" is a constructor or destructor, which takes before and after hooks only |
Lib.ImportRowBad |
import {row} is not one luma.h makes |
Lib.ImportsUnreadable |
its list of imports points outside the library |
Lib.InfoTooSmall |
it is shorter than luma.h's LumaModInfo (it was not built with luma.h) |
Lib.InfoUnreadable |
it points outside the library |
Lib.NoIos |
it does not say it is built for iOS devices (no LC_BUILD_VERSION or LC_VERSION_MIN_IPHONEOS) |
Lib.NoNames |
loaded as a whole |
Lib.NotALibrary |
not a library of any system |
Lib.NotIos |
it is built for {found}, not for iOS devices |
Lib.NotLumaH |
its luma_mod says api 0 (it was not built with luma.h) |
Lib.NotShared |
a {kind} file that is not a shared library |
Lib.RunsAtClose |
the system would run its {found} when it closes it, after the mod's memory is freed: build it with luma.h's flags |
Lib.RunsAtLoad |
the system would run its {found} when it loads it, before the mod is started: build it with luma.h's flags |
Lib.StartFaulted |
its begin or start failed and the guard stopped it (see its GUARD entry) |
Lib.StartRefused |
its start refused to run (it returned {found}) |
Lib.ThirtyTwoBit |
a 32-bit library |
Lib.TooManyImports |
it lists more than 65536 imports |
Lib.TooManyMods |
more mods with code are on than the {count} this game takes |
Lib.Universal |
a universal Mach-O file holding several machines (give one file per platform) |
Lib.WholeLibrary |
loaded as a whole |
#Hooks
| Key | Words |
|---|---|
Hook.Constexpr |
"{found}" is constexpr: the game may run it while it is being built, so it takes no hooks |
Hook.NoDefaultResult |
{found} gives a result that has no empty value, so a hook may not skip it, wrap it or replace it |
Hook.Variadic |
"{found}" takes a variable number of arguments, so it takes before hooks only; the function it passes them to with a va_list takes every hook |
#Names the game's self-description leaves out
| Key | Words |
|---|---|
LeftOut.AliasTwice |
a name that .cpp files give to different types: {what} |
LeftOut.Ambiguous |
{what} each have it |
LeftOut.InstanceInCpp |
a template instance only a .cpp file names |
LeftOut.InternalLinkage |
internal linkage: no name a mod can bind |
LeftOut.KernelOwn |
LumaCore's own |
LeftOut.NoName |
no name a mod can write |
LeftOut.NoSize |
no size: incomplete or dependent |
LeftOut.NotDefined |
declared, but nothing in the game defines it |
LeftOut.TemplateMember |
a static member of a class template |
LeftOut.TemplateUnused |
a template the game never uses with these arguments |
LeftOut.ThreadLocal |
thread-local: one per thread, no single address |
LeftOut.TypeNoName |
its type has no name a mod can write |
LeftOut.VirtualBase |
reached through the virtual base {what} |
LeftOut.WideBitField |
a bit-field wider than 32 bits |
#Library data
| Key | Words |
|---|---|
Kit.AnyOf |
{key} matches none of the schema's {count} choices |
Kit.DeclaredNoFolder |
kit names {module}, but there is no kit/{module}/ folder |
Kit.Enum |
{key} is {found}; it must be one of {expected} |
Kit.FolderNotDeclared |
there is a kit/{module}/ folder, but kit does not name {module} |
Kit.Least |
{key}: {what} is {found}; the least allowed is {min} |
Kit.LessThan |
{key}: {what} is {found}; it must be less than {max} |
Kit.MoreThan |
{key}: {what} is {found}; it must be more than {min} |
Kit.Most |
{key}: {what} is {found}; the most allowed is {max} |
Kit.NoModuleData |
none |
Kit.NotAllowed |
{key} has "{name}", which the schema does not allow |
Kit.NotData |
{entry} is never read: a module reads only kit/<module>/<name>.json, the name 1 to 64 of a-z, 0-9, _, - and ., not starting with a dot |
Kit.NotJson |
not JSON: {found} |
Kit.NotNeeded |
kit names {module}, which is no module of this mod or of a mod in needs |
Kit.OneOf |
{key} matches {found} of the schema's {count} choices; it must match exactly one |
Kit.Pattern |
{key} is {found}, which does not match the pattern {expected} |
Kit.Repeated |
{key} has {found} more than once; its items must differ |
Kit.Required |
{key} has no "{name}", which the schema requires |
Kit.SchemaKeyword |
the data schema {entry} has "{found}" at {key}, which the kit schema form does not read |
Kit.SchemaPlace |
{entry}: a library's data schema is code/<id>.kit/<module>/<version>.json, the version a whole number from 1 to 1000000 |
Kit.SchemaUnread |
the data schema {entry} is not JSON: {found} |
Kit.Type |
{key} is {found}; the schema's type is {expected} |
Kit.What.Bytes |
the size in bytes |
Kit.What.Items |
the number of items |
Kit.What.Keys |
the number of keys |
Kit.What.Length |
the number of characters |
Kit.What.Value |
the value |
#Rules not checked
| Key | Words |
|---|---|
Missing.AfterStart |
a class no list of the game names may be one a mod's code makes; the game checks it once the mods have started |
Missing.Classes |
the game's list of classes was not given; it comes with the game's self-description |
Missing.Device |
what this device's graphics have is known only when the game starts the mod |
Missing.Fields |
the game's list of fields was not given; it comes with the game's self-description |
Missing.Game |
no game was given to check against |
Missing.Load |
how many rows a selector matches is known only when the game loads the mod |
Missing.ModFolder |
no mod folder was given to find the needed mods in |
Missing.NewScenarios |
a new galaxy's scenario table this mod brings could not be read as a table (which layers are on together) |
Missing.OtherModRows |
another mod's rows are known only when the game loads the mods |
Missing.RendererFeatures |
the game's list of graphics features (luma_renderer.json) was not given; it comes with the game's self-description |
Missing.Rows |
the game's rows of this file were not given |
Missing.Scenarios |
the galaxies' scenario tables were not given (which layers are on together) |
Missing.SelfDescription |
the game's self-description was not given |
Missing.ServiceImports |
which services a library uses cannot be read from it yet |
Missing.Services |
the game's list of services (their versions and permissions) was not given |
Missing.SigningRules |
the iOS signing rules for extra libraries are not defined yet |
Missing.Store |
the game's files were not given |
Missing.Types |
the game's types file (luma_types.json) was not given; it comes with the game's self-description |
Missing.Virtuals |
the game's types file (luma_types.json) does not list virtual functions; a newer one comes with the game's self-description |
#Opening a file
| Key | Words |
|---|---|
Open.Denied |
this program may not read {detail} |
Open.File |
the file cannot be read ({detail}) |
Open.Folder |
the folder cannot be read ({detail}) |
Open.NotFound |
{detail} does not exist |
Open.TooDeep |
its folders go more than 64 deep, at {detail} |
#Preparing files
| Key | Words |
|---|---|
Cook.Anim.ModelUnread |
the game's {model} was imported by an older Nebula, so its materials and textures cannot be read here: import the game again |
Cook.Anim.NoGame |
{file}: an animation file is made from the game's model, which is not known here (give the game: --game) |
Cook.Anim.NoGameMaterial |
the animation file's material {material} is no material of the game's {model} (its materials: {materials}) |
Cook.Anim.NoGameTexture |
the animation file swaps in the texture {texture}, which is no texture of the game's {model} (its textures: {textures}) |
Cook.Anim.NoName |
animation {animation} has no name; its name is the name of the clip it makes |
Cook.Anim.None |
{file} has no animation |
Cook.Anim.NotAJoint |
animation {animation} moves {node}, which is no joint of the game's model {model} |
Cook.Anim.NotANumber |
animation {animation} has a key that is not a number (NaN or infinite) |
Cook.Anim.NotInArchive |
{file}: an animation file goes in the archive of the model it moves (ObjectData/<Name>.arc/) |
Cook.Anim.OnlyJoints |
animation {animation} animates {path}; an animation file moves joints and materials (their color and texture transform) only |
Cook.Anim.ParentDiffers |
joint {joint} hangs from {found} here but from {parent} in the game's model; the game's clips move each joint from its parent |
Cook.Anim.ParentMissing |
joint {joint} hangs from {parent} in the game's model but from no joint here |
Cook.Anim.RootDiffers |
joint {joint} is the game model's root but hangs from {found} here |
Cook.Anim.TextureUnnamed |
{texture}: a texture an animation file swaps in is the game's texture of its image's name (give the image a name, or a file name, as {model} names its textures) |
Cook.Anim.TooLong |
animation {animation} lasts {seconds} seconds; a clip lasts at most {max} |
Cook.Anim.Twice |
two animations are named {name} |
Cook.Anim.WhichModel |
{archive} has more than one model ({models}) and none has the archive's name: an animation file there cannot tell which it moves |
Cook.Camera.NoAnimation |
no animation moves the camera's node or its yfov |
Cook.Camera.NoFov |
camera {camera} has no yfov |
Cook.Camera.None |
no node has a camera: give the camera's node a "camera" |
Cook.Camera.NotPerspective |
camera {camera} is not a perspective camera |
Cook.Camera.ParentMoves |
the camera's parent node {node} moves: animate the camera's own node |
Cook.Cell.Number |
column "{name}" holds a number: give it a number |
Cook.Cell.Text |
column "{name}" holds text: give it text |
Cook.Cell.Whole |
column "{name}" holds a whole number: give it a whole number |
Cook.Clip.Plays |
the animation {animation} plays "{found}"; it can play once, once_then_first, loop, there_and_back or loop_there_and_back |
Cook.Clip.Pointer |
the animation {animation} moves {pointer}; an animation can move a material's baseColorFactor and its base color texture's KHR_texture_transform |
Cook.Clip.SwapNoKeys |
the animation {animation}'s texture swap of the material {material} has no keys |
Cook.Clip.SwapNoTexture |
the animation {animation} swaps the textures of the material {material}, which has no base color texture |
Cook.Clip.Undrawn |
the animation {animation} changes the material {material}, which no mesh draws |
Cook.Collision.Attribute |
a collision part uses material {found}; the most is {max} |
Cook.ConsoleOnly |
{file}: only the console reads this file (its banner, HOME menu or module list); the game has no use for it |
Cook.Effect.Choice |
{where} is "{value}", which is not one of {expected} |
Cook.Effect.Color |
{where} is "{value}", not a color written as rrggbbaa |
Cook.Effect.Count |
the mods' particles come to {count}; the game takes at most {max} |
Cook.Effect.Empty |
{where} has no particle; an effect has at least one |
Cook.Effect.FileMissing |
{where} names the file "{uri}", which the mod does not have |
Cook.Effect.FilePath |
{where} names the file "{uri}"; a texture's file is a path inside the layer's assets folder, with / between folders and no .. or : |
Cook.Effect.Frames |
{where} comes to {count} textures; a particle takes at most 255 |
Cook.Effect.Is.Bool |
true or false |
Cook.Effect.Is.List |
a list in [ ] |
Cook.Effect.Is.Number |
a number |
Cook.Effect.Is.Object |
names with values, in braces |
Cook.Effect.Is.Text |
text in quotes |
Cook.Effect.Is.Whole |
a whole number |
Cook.Effect.Keys |
the keys at {where} need at least one key, each a list that starts with its frame, the frames rising |
Cook.Effect.Kind |
{where} must be {expected} |
Cook.Effect.Length |
{where} holds {found} values; it takes {count} |
Cook.Effect.LikeUnknown |
{where} names "{name}", which is not one of the game's particles |
Cook.Effect.Missing |
{where} needs "{key}" |
Cook.Effect.NameBad |
the effect name "{name}" at {where} may use only lowercase letters, digits and _, must start with a letter, be at most 64 long and not end in two digits |
Cook.Effect.NoTexture |
{where} names the texture "{name}", which is neither one of the file's textures nor one of the game's particle textures |
Cook.Effect.OldForm |
particles are written in effects.json in a layer's assets folder, not as Particles.jpc.json |
Cook.Effect.Overlap |
two mods replace the game's particle "{name}": {winner}'s is used, not {other}'s |
Cook.Effect.Positional |
{where} is a list; name each texture by its role: sprite, child, second or indirect |
Cook.Effect.Range |
{where} is {value}, outside {min} to {max} |
Cook.Effect.RawIndex |
{where}: a particle names its textures by role, not by number; give the texture's name as "{role}" in its textures |
Cook.Effect.ReplaceUnknown |
{where}: the game has no particle "{name}" to replace |
Cook.Effect.RoleOff |
{where} gives a texture as "{role}", but the particle does not draw that one: its record is missing or turned off |
Cook.Effect.TableNoFirst |
{where}: the effect name "{word}" starts the particles {word}00, {word}01 and on, and there is no {word}00 |
Cook.Effect.TableUnknown |
{where}: "{word}" in the effect name is not a particle of the game or of any mod that is on |
Cook.Effect.TextureName |
the texture name "{name}" at {where} may use only letters, digits, _, - and ., and be 1 to 64 long |
Cook.Effect.TooMany |
{where} has {count} particles; an effect has at most {max} |
Cook.Effect.UnknownPart |
{where} has no part "{key}"; its parts are {expected} |
Cook.Effect.UnknownValue |
{where} has no value "{key}"; its values are {expected} |
Cook.EmptyFile |
{file} is empty |
Cook.Events.ClipName |
{file}: the clip's name (the file's name before .anim.json) is 1 to {max} bytes |
Cook.Events.ClipUnknown |
{file}: the game's {archive} has no clip {clip}; the frames are not checked against a clip here |
Cook.Events.GameUnknown |
{file}: the game is not known here, so the frames are not checked against the clip (give the game: --game) |
Cook.Events.Name |
{where}: the event "{name}" is 1 to {max} of the letters A-Z a-z, the digits 0-9, _ and . |
Cook.Events.None |
{file} has no event |
Cook.Events.NotInArchive |
{file}: a clip's events go in the archive of the clip (ObjectData/<Name>.arc/<clip>.anim.json) |
Cook.Events.PastEnd |
{where}: frame {frame} is past the end of clip {clip}, whose last frame is {last} |
Cook.Events.TooMany |
{file} has {count} events; a clip has at most {max} |
Cook.Events.Twice |
{where}: event {event} at frame {frame} is given twice |
Cook.Failed |
the game's file cannot be made from it: {detail} |
Cook.Font.Beyond |
{where}: {char} is past U+FFFF, and the game's text draws characters up to U+FFFF |
Cook.Font.Code |
{where} is "{value}": a character is given as a number or as U+ and its hexadecimal code (U+00E9) |
Cook.Font.KernCut |
{uri} has {count} kerning pairs; the {max} that move most are kept |
Cook.Font.Missing |
{uri} has no glyph for {count} of the characters asked for ({chars}); {fallback} draws them |
Cook.Font.NoGlyph |
{uri} draws none of the characters asked for (Latin, and the source's chars and ranges) |
Cook.Font.NotAsset |
{file}: a font goes in a layer's assets folder (assets/<path>.font.json); a text names it Luma/<id>/<path> |
Cook.Font.RangeOrder |
{where}: the first character comes after the last |
Cook.Font.TooLarge |
{uri} at size {size} is more than the game's fonts hold (a line or a character up to 127 pixels, a cell up to 255); the largest size that fits is {most} |
Cook.Font.TooMany |
{uri} at size {size} has {count} characters, and at most {max} fit: ask for fewer characters or a smaller size |
Cook.Font.Unreadable |
{uri} is not a TrueType or OpenType font that can be read |
Cook.Image.Kind |
the image {image} is neither PNG nor JPEG |
Cook.Image.Side |
the image {image} is {width} by {height} pixels; images go up to {max} pixels a side |
Cook.Image.Unreadable |
the image {image} cannot be read |
Cook.Layout.Both |
{where} gives both "{key}" and "{other}"; give one of them |
Cook.Layout.Control |
{where} holds a control character; text takes letters, signs and line breaks (\n) |
Cook.Layout.Name |
the name "{name}" at {where} may use only letters, digits and _, and be 1 to 16 long |
Cook.Layout.NoFont |
{where} names the font "{name}", but the mod has no {uri} in any layer |
Cook.Layout.NoPane |
{where} names the pane "{name}", which the layout does not have |
Cook.Layout.NoTexture |
{where} names the texture "{name}", but the mod has no {uri} |
Cook.Layout.NotInArchive |
{file}: a layout goes in its own archive (LayoutData/<Name>.arc/<Name>.layout.json) |
Cook.Layout.NotLayout |
the game's layout file does not read as a layout (its blocks run past its end) |
Cook.Layout.PatchPlace |
{where}: a patch of a game layout goes in a layer's patches/ as <archive>/blyt/<Name>.brlyt.json, so other mods' patches of it combine |
Cook.Layout.TextLong |
{where} has {count} characters; the pane holds {max} (its length) |
Cook.Layout.TextTall |
{where}: {lines} lines are {height} high; the pane is {max} high |
Cook.Layout.TextWide |
{where}: the line "{line}" is at least {width} wide; the pane is {max} wide |
Cook.Layout.TooMany |
the layout has {count} panes; a layout holds at most {max} |
Cook.Layout.Twice |
{where}: the name "{name}" is used twice; a pane or group is found by its name |
Cook.LeftOut.Console |
only the console's own menus read it |
Cook.LeftOut.Tool |
the tools that made the game left it in the archive; no code opens it |
Cook.Material.Clamped |
the material {material}'s {factor} is {found}, outside what glTF allows; it was brought to the nearest allowed value |
Cook.Material.CoordSet |
the material {material}'s {map} reads texture coordinates {set}, which the mesh {mesh} does not have |
Cook.Material.MissingTexture |
the material {material}'s {map} names texture {texture}, which has no image in the file |
Cook.Material.Ray |
the material {material}: {key} is not a ray value a material takes, or not in its range (ior, thickness, body, shine, tint_keep, traced, sun_through, metal_kind, glow, vertex_colour) |
Cook.Material.TextureTransform |
the material {material}'s {map} has a KHR_texture_transform; it was baked into its texture coordinates |
Cook.Material.TransformShared |
the material {material}'s {map} has its own KHR_texture_transform on texture coordinates {set}, which another of its textures also reads; give it a set of its own |
Cook.Merge.ChangeForm |
each item of "change" must have a "where" and a "set", each a set of columns |
Cook.Merge.ChangeNoRow |
"change" where {row} matched no row; the rest of the file was added |
Cook.Merge.NoBase |
the game has no {file} to add to, and the mod brings none |
Cook.Merge.NoColumn |
the table has no column "{name}" |
Cook.Merge.RemoveForm |
each item of "remove" must be a set of columns |
Cook.Merge.RemoveNoRow |
"remove" {row} matched no row; the rest of the file was added |
Cook.Model.Accessor |
accessor {accessor} has {count} elements; a model has up to {max} |
Cook.Model.AccessorPast |
accessor {accessor} reaches past its buffer view |
Cook.Model.Billboard |
the node {node}'s billboard is {value}; it can be "y" or "xy" |
Cook.Model.Blends |
the mesh {mesh} needs more blends of joints than a model has room for ({max}) |
Cook.Model.ColorSets |
the mesh {mesh} has {count} vertex color sets; a mesh has up to {max} |
Cook.Model.CoordSets |
the mesh {mesh} uses {count} texture coordinate sets; a mesh has up to {max} |
Cook.Model.Cut |
the .glb file is cut off |
Cook.Model.Extension |
the file requires {name}, which Nebula does not read; export it without (Nebula reads {read}) |
Cook.Model.FlatNormals |
the mesh {mesh} has no normals: each triangle was given its own (flat shading) |
Cook.Model.GameUnknown |
the game's model for {file} was not read: its joints keep the file's numbers, not the game's |
Cook.Model.Hide |
{file}: a model entry holds exactly "hide": true, which hides the game's model it names |
Cook.Model.HideNoGame |
{file}: a hidden model keeps the game model's joints, and that model is not known here (give the game: --game) |
Cook.Model.Invalid |
the file is not valid glTF 2.0 at {where}: it is missing or not what glTF says it is |
Cook.Model.JointName |
joint "{joint}" has a letter the game's models cannot hold; name it with English letters, digits and signs only |
Cook.Model.JointTwice |
two joints are named "{joint}"; each joint needs a name of its own |
Cook.Model.Joints |
the model has {count} joints; a model has up to {max} |
Cook.Model.Json |
the file's JSON cannot be read (line {line}, column {column}) |
Cook.Model.Layers |
the material {material} has {count} textures or coordinate sets; a material has up to {max} |
Cook.Model.Leaves |
"{uri}" points outside the model's folder: keep the model's files beside it |
Cook.Model.LevelAlone |
{file} is a level of detail of the model {model}, which the mod does not have; add {model} or give the file another name |
Cook.Model.MaterialName |
material "{material}" has a letter the game's models cannot hold; name it with English letters, digits and signs only |
Cook.Model.Meshes |
the model has {count} meshes; a model has up to {max} |
Cook.Model.MissingJoint |
the game's model {model} has the joint "{joint}", which this model lacks; the game's animations and code move joints by these names |
Cook.Model.NoGameModel |
{archive} has no game model of this name (its models: {models}); a new model goes in assets/ |
Cook.Model.NoPositions |
mesh {mesh} has a part with no POSITION attribute |
Cook.Model.NoTriangles |
the model has no triangles |
Cook.Model.NodeMissing |
the file names node {node}, which it does not have |
Cook.Model.NotTriangles |
the mesh {mesh} is drawn as points or lines (mode {mode}); a model is drawn in triangles |
Cook.Model.SkinNoWeights |
the mesh {mesh} has a skin but no JOINTS_0 and WEIGHTS_0 |
Cook.Model.SkinOutside |
the skin names the node {node}, which is not in the scene |
Cook.Model.SocketIsJoint |
the socket "{name}" has the name of a joint; give it a name of its own |
Cook.Model.SocketTwice |
two sockets are named "{name}" |
Cook.Model.TransformNoTexture |
the material {material} has a texture transform but no base color texture |
Cook.Model.TwoGameModels |
{archive} has both {name}.bdl and {name}.bmd: name the file {name}.bdl.glb or {name}.bmd.glb |
Cook.Model.TwoSkins |
the meshes {mesh} and {other} have different skins; a model has one skin |
Cook.Model.UnevenTransform |
the material {material}'s texture is turned with unequal scales; scale it evenly, or do not turn it |
Cook.Model.Unreadable |
"{uri}", a file the model names, cannot be read |
Cook.Model.Unweighted |
{count} vertices of the mesh {mesh} have no weight: they follow the skin's root |
Cook.Model.Version |
the file is glTF "{found}"; Nebula reads glTF 2.0 |
Cook.Model.VertexPast |
a triangle of the mesh {mesh} names vertex {vertex}; the mesh has {count} |
Cook.Model.ViewPast |
buffer view {view} reaches past its buffer |
Cook.Model.WeightsOver4 |
the mesh {mesh} weighs {vertices} vertices on more than four joints; a vertex follows up to four |
Cook.Movie.AudioTrack |
{uri}: its own sound track ({found}) is not read; give the sound as a WAV, FLAC or Ogg Vorbis file in audio |
Cook.Movie.Codec |
{uri} is {found}; give the video as AV1 in WebM or IVF (the game decodes AV1 itself on every system) |
Cook.Movie.Colour |
{uri} has the color {found}; give BT.709 limited range or BT.601 full range |
Cook.Movie.File |
{uri} cannot be read as a WebM or IVF movie: {detail} |
Cook.Movie.FirstKey |
{uri} does not start with a key frame |
Cook.Movie.Form |
{uri} is AV1 {found}; the game decodes AV1 main profile, 8 bits, 4:2:0 |
Cook.Movie.Name |
{where}: "{name}" is not a game movie's name (its file name in MovieData without .thp) |
Cook.Movie.NoGameMovie |
{where} names the game movie "{name}", which the game does not have |
Cook.Movie.NotAsset |
{file}: a movie goes in a layer's assets folder (assets/<path>.movie.json) |
Cook.Movie.Rate |
{uri} plays at {value} frames a second; a movie plays at more than 0 and at most {max} |
Cook.Movie.Size |
{uri} is {width} x {height}; a movie is at most 1920 x 1080 (or 1080 x 1920) |
Cook.Movie.Subtitle |
{where}: the subtitle's time {value} is not inside the movie's {seconds} seconds, or ends before it starts |
Cook.Movie.TooLong |
the movie lasts {seconds} seconds; a movie lasts at most {max} |
Cook.NotArchive |
{file} is named as an archive (.arc) but is not one |
Cook.Post.Forbidden |
{file} line {line}: a screen pass may not write {word}; the scene, depth, motion, its parameters and the entry point come from the game |
Cook.Post.Json |
{file}: {key} is not what a screen pass's interface takes (params with name, type float to float4 and default; reads depth and motion; draw contract 15) |
Cook.Post.Missing |
{file} is a screen pass, but the mod has no {other} beside it |
Cook.Post.NoPost |
{file} defines no post(PostIn i) |
Cook.Post.Text |
{file} is not UTF-8 text |
Cook.Post.TooLarge |
{file} is {value} bytes; a screen pass has at most {max} |
Cook.Post.TooManyParams |
{file}: the parameters take {count} floats; a screen pass has {max}, in 4 rows of 4, and a parameter never crosses a row |
Cook.Post.Twice |
{file}: the name "{name}" is given twice |
Cook.Shader.Compile |
{file} line {line} does not compile for {target}: {detail} |
Cook.Shader.CompileProgram |
the material {material} with the shader {file} does not compile for {target} where the shader's code meets the material's: {detail} |
Cook.Shader.Compiler |
the shader compiler {file} did not run: {detail} |
Cook.Shader.Forbidden |
{file} line {line}: a shader may not write {word}; its parameters, textures and inputs come through SurfaceIn and Surface |
Cook.Shader.Json |
{file}: {key} is not what a shader's interface takes (stage material; params, textures and reads as the materials contract 3.4 says) |
Cook.Shader.Materials |
{count} materials of the model have a shader; a model has at most {max} |
Cook.Shader.Missing |
the material {material} names the shader "{name}", but the mod has no {file} in any layer |
Cook.Shader.Name |
the material {material} names the shader "{name}": a shader is named by its path under assets without its ending (letters, digits, _ and -) |
Cook.Shader.NoSurface |
{file} defines no surface(in SurfaceIn i, inout Surface s) |
Cook.Shader.NoTexture |
the material {material} gives no texture for {texture} of the shader {shader} |
Cook.Shader.NotCompiled |
the shader {file} of the material {material} was not compiled for {target}: no compiler was found ({name} beside LumaLink or the game) |
Cook.Shader.ParamRange |
the parameter {param} of the material {material} is outside {min} to {max}, what its place holds |
Cook.Shader.ParamType |
the material {material} gives the parameter {param} a value that is not a {expected} |
Cook.Shader.Text |
{file} is not UTF-8 text |
Cook.Shader.TooLarge |
{file} is {value} bytes; a shader has at most {max} |
Cook.Shader.TooManyParams |
the shader of the material {material} has {count} parameters; {max} of the material's places are free |
Cook.Shader.Twice |
{file}: the name "{name}" is given twice |
Cook.Shader.UnknownParam |
the material {material} gives the parameter {param}, which the shader {shader} does not have |
Cook.Shader.UnknownTexture |
the material {material} gives the texture {texture}, which the shader {shader} does not have |
Cook.Shader.Unlit |
the material {material} is unlit (KHR_materials_unlit), so the shader {shader} has no light to fill |
Cook.Sound.Broken |
{uri} is damaged at byte {value} |
Cook.Sound.Channels |
{uri} has {count} channels; a sound effect has at most {max} |
Cook.Sound.Cut |
{uri} ends before the sound it describes; it was cut short |
Cook.Sound.Empty |
{uri} has no sound in it |
Cook.Sound.InstrumentKey |
{where}: "{name}" is not a MIDI program (0 to 127) or drums |
Cook.Sound.LoopOutside |
the loop {value} of {uri} is not inside its {count} frames, or is empty |
Cook.Sound.Midi |
{uri} cannot be read as a Standard MIDI file: {detail} |
Cook.Sound.MidiDropped |
{uri}: left out, as the game's sequences do not play them: {detail} |
Cook.Sound.NoGameSequence |
{where} names the game sequence "{name}", which the game does not have |
Cook.Sound.NoGameSound |
{where} names the game sound "{name}", which the game does not have |
Cook.Sound.NoGameStream |
{where} names the game stream "{name}", which the game does not have |
Cook.Sound.NoInstrument |
{uri} plays the MIDI program {name}, which instruments does not map to a game instrument |
Cook.Sound.NotANumber |
{uri} holds a sample that is not a number |
Cook.Sound.NotAsset |
{file}: a sound effect goes in a layer's assets folder (assets/<path>.sound.json) |
Cook.Sound.Opus |
{uri} is Ogg Opus; give the sound as WAV, FLAC or Ogg Vorbis |
Cook.Sound.Order |
{where}: the first number must be smaller than the second |
Cook.Sound.Rate |
{uri} is sampled at {value} Hz; give it at {min} to {max} Hz |
Cook.Sound.Sequence |
{uri} made a sequence the game's sequence cook refuses: {detail} |
Cook.Sound.SequenceName |
{where}: "{name}" is not a path in the game's sequence archive (AudioRes/Seqs/JaiSeq.arc) |
Cook.Sound.StreamChannels |
{uri} has {count} channels; a stream has at most {max} |
Cook.Sound.StreamFile |
{uri} cannot be read as a BRSTM, BCSTM or BFSTM stream: {detail} |
Cook.Sound.StreamName |
{where}: "{name}" is not a game stream's name (its file name in AudioRes/Stream without .ast) |
Cook.Sound.StreamTooLong |
the stream lasts {seconds} seconds; a stream lasts at most {max} |
Cook.Sound.TooLong |
the sound lasts {seconds} seconds; a sound effect lasts at most {max} (longer music is a stream) |
Cook.Sound.Unreadable |
{uri} is not a WAV, FLAC or Ogg Vorbis file |
Cook.Sound.WavKind |
{uri} is a WAV of format {kind} with {width}-bit samples; give it as 8-, 16-, 24- or 32-bit PCM or 32- or 64-bit float |
Cook.Stage.ArgName |
{where}: {other} has no argument "{name}"; its arguments are {expected} |
Cook.Stage.ArgTwice |
{where}: "{name}" is {column}, which the row already gives |
Cook.Stage.NoFacts |
arguments by name need the game's placement facts ({uri}), which could not be read; reinstall the game, or give Obj_arg0 to Obj_arg7 |
Cook.Stage.NoObject |
{where} gives arguments by name, but the game has no object "{name}" to take them from; give Obj_arg0 to Obj_arg7 |
Cook.Table.CellKind |
row {row}: "{name}" must be text or a number |
Cook.Table.ColumnKind |
column "{name}" in "columns" must be int, float or string |
Cook.Table.Json |
the table's JSON cannot be read (line {line}, column {column}) |
Cook.Table.KindChanged |
row {row}: "{name}" is another kind of value than in the rows before |
Cook.Table.NoRows |
the table has no "rows" list |
Cook.Table.RowNotObject |
row {row} is not a set of columns |
Cook.Text.TagArguments |
{key}, column {column}: [{word}] is written {syntax} |
Cook.Text.TagNumber |
{key}, column {column}: {value} in [{word}] is not a number from 0 to {most} |
Cook.Text.Unclosed |
{key}, column {column}: a "[" with no "]"; write "[[" for a bracket of its own |
Cook.Text.UnknownTag |
{key}, column {column}: "[{word}" is no message tag; write a tag word, or "[[" for a bracket of its own |
Cook.Texture.DdsForm |
the image {image} is a DDS the game does not read; it reads one flat picture in BC1 to BC5, BC7, or 8-bit RGBA or BGRA |
Cook.ToolFile |
{file} is left out: only the tools that made the game use a file like it, and no code opens it |