o3de/Registry/AssetProcessorPlatformConfig.setreg

{
    // ---- Enable/Disable platforms for the entire project. AssetProcessor will automatically add the current platform by default.

    // PLATFORM DEFINITIONS
    // [Platform (unique identifier)]
    // tags=(comma-seperated-tags)
    //
    // note:  the 'identifier' of a platform is the word(s) following the "Platform" keyword (so [Platform pc] means identifier
    //        is 'pc' for example.  This is used to name its assets folder in the cache and should be used in your bootstrap.cfg
    //        or your main.cpp to choose what assets to load for that particular platform.
    //        Its primary use is to enable additional non-host platforms (Ios, android...) that are not the current platform.
    // note:  'tags' is a comma-seperated list of tags to tag the platform with that builders can inspect to decide what to do.

    // while builders can accept any tags you add in order to make decisions, common tags are
    // tools - this platform can host the tools and editor and such
    // renderer - this platform runs the client engine and renders on a GPU.  If missing we could be on a server-only platform
    // mobile - a mobile platform such as a set top box or phone with limited resources
    // console - a console platform
    // server - a server platform of some kind, usually headless, no renderer.

    "Amazon": {
        "AssetProcessor": {
            "Settings": {
                "Stats": {
                    // Setting MachineReadable to true will output stats in more of a CSV-like format that is ideal for script ingestion
                    "MachineReadable" : false,
                    // Setting HumanReadable to true will output stats in a friendly human format that is ideal for human reading
                    "HumanReadable" : true,
                    // To turn off stats output entirely, set both HumanReadable and MachineReadable to false.
                    // the maximum number of stats to show for cumulative stats like the time taken
                    // across all jobs of a certain type, or all jobs cumulative across a whole platform
                    "MaxCumulativeStats" : 4,
                    // the maximum number of stats to show for individual stats like how long a specific
                    // individual job took.
                    "MaxIndividualStats" : 4
                },
                "BuilderManager": {
                    // Number of seconds to wait for AssetBuilder process to start before terminating the process
                    "StartupTimeoutSeconds" : 900
                },
                "Platform pc": {
                    "tags": "tools,renderer,dx12,vulkan,null"
                },
                "Platform linux": {
                    "tags": "tools,renderer,vulkan,null"
                },
                "Platform android": {
                    "tags": "android,mobile,renderer,vulkan"
                },
                "Platform ios": {
                    "tags": "mobile,renderer,metal"
                },
                "Platform mac": {
                    "tags": "tools,renderer,metal,null"
                },
                // this is an example of a headless platform that has no renderer.
                // To use this you would still need to make sure 'assetplatform' in your startup params in your main() chooses this 'server' platform as your server 'assets' flavor
                "Platform server": {
                    "tags": "server,dx12,vulkan,null"
                },
                // this section allows you to turn on various platforms in addition to the host platform you're running on
                // 'enabled' is AUTOMATICALLY TRUE for the current platform that you are running on, so it is not necessary to force it to true for that platform
                // To enable any additional platform, just uncomment the appropriate line below.
                "Platforms": {
                    //"pc": "enabled",
                    //"android": "enabled",
                    //"ios": "enabled",
                    //"mac": "enabled",
                    //"server": "enabled"
                },
                // ---- The number of worker jobs, 0 means use the number of Logical Cores
                "Jobs": {
                    "minJobs": 1,
                    "maxJobs": 0
                },
                // cacheServerAddress is the location of the asset server cache.
                // Currently for a network share server this would be the absolute file path to the network share folder.
                "Server": {
                    //"cacheServerAddress": ""
                },

                // ---- add any metadata file type here that needs to be monitored by the AssetProcessor.
                // Modifying these meta file will cause the source asset to re-compile again.
                // They are specified in the following format
                // metadata extension=original extension to replace
                // if the metadata extension does not replace the original, then the original can be blank
                // so for example if your normal file is blah.tif and your metafile for that file is blah.tif.exportsettings
                // then your declaration would be exportsettings=   ; ie, it would be blank
                // however if your metafile REPLACES the extension (for example, if you have the file blah.i_caf and its metafile is blah.exportsettings)
                // then you specify the original extension here to narrow the scope.
                // If a relative path to a specific file is provided instead of an extension, a change to the file will change all files
                // with the associated extension (e.g. Animations/SkeletonList.xml=i_caf will cause all i_caf files to recompile when
                // Animations/SkeletonList.xml within the current game project changes)

                "MetaDataTypes": {
                    "animsettings": "i_caf",
                    "Animations/SkeletonList.xml": "i_caf",
                    "cbc": "abc",
                    "fbx.assetinfo": "fbx",
                    "stl.assetinfo": "stl",
                    "gltf.assetinfo": "gltf",
                    "glb.assetinfo": "glb"

                },

                // ---- add any folders to scan here.  The priority order is the order they appear here
                // available macros are
                // @ROOT@ - the location of asset root
                // @PROJECTROOT@ - the location of the project root, for example 'Q:\MyProjects\RPGSample'
                // note that they are sorted by their 'order' value, and the lower the order the more important an asset is
                // lower order numbers override higher ones.
                // If specified, output will be prepended to every path found in that recognizer's watch folder.
                // Note that you can also make the scan folder platform specific by using the keywords include and exclude.
                // Both include and exclude can contain either platform tags, platform identifiers or both.
                // if no include is specified, all currently enabled platforms are included by default.
                // If includes ARE specified, it will be filtered down by the list of currently enabled platforms.
                // "ScanFolder (unique identifier)": {
                //  "include": "(comma seperated platform tags or identifiers)",
                //  "exclude": "(comma seperated platform tags or identifiers)"
                // }
                // For example if you want to include a scan folder only for platforms that have the platform tags tools and renderer
                // but omit it for platform mac, you will have a scanfolder rule like
                // "ScanFolder (unique identifier)": {
                // "watch": "@ROOT@/foo",
                // "include": "tools, renderer",
                // "exclude": "mac"
                // }

                "ScanFolder Project/Assets": {
                    "watch": "@PROJECTROOT@",
                    "display": "@PROJECTNAME@",
                    "recursive": 1,
                    "order": 0
                },
                "ScanFolder Root": {
                    "watch": "@ROOT@",
                    "recursive": 0,
                    "order": 10000
                },
                "ScanFolder Assets/Runtime": {
                    "watch": "@ENGINEROOT@/Assets/Engine",
                    "recursive": 1,
                    "order": 20000
                },
                "ScanFolder Assets/Tools": {
                    "watch": "@ENGINEROOT@/Assets/Editor",
                    "recursive": 1,
                    "order": 30000,
                    "include": "tools,renderer"
                },
                "ScanFolder Engine/Registry": {
                    "watch": "@ENGINEROOT@/Registry",
                    "recursive": 1,
                    "order": 40000
                },

                // Configurable starting priority for all Gem scan folders to use.
                // Each Gem scan folder added will increment this.
                // NOTE: Each successive gem priority will be lower than the last.
                "GemScanFolderStartingPriorityOrder": 100,

                // Control how project-relative Gem scan folders are prioritized against the project's main scan folder (key: "Project/Assets", alias: @PROJECTROOT@).
                //  "none" - any project Gem scan folder priority will be incremented from the "GemScanFolderStartingPriorityOrder" value (default behavior).
                //  "lower" - each project Gem scan folder will be set to lower priority (higher numeric value) than the project scan folder.
                //  "higher" - each project Gem scan folder will be set to higher priority (lower numeric value) than the project scan folder.
                "ProjectRelativeGemsScanFolderPriority": "none",

                // Excludes files that match the pattern or glob.
                // the input string will be the relative path from the scan folder the file was found in.
                // patterns are case sensitive regular expressions, while globs are simple wildcard matches (non-case-sensitive)
                // if you use a pattern, remember to escape your backslashes (\\)
                "Exclude _LevelBackups": {
                    "glob": "*/_savebackup/*"
                },
                "Exclude _LevelAutoBackups": {
                    "glob": "*/_autobackup/*"
                },
                // note that $ has meaning to regex, so we escape it.
                "Exclude TempFiles": {
                    "pattern": "(^|.+/)\\\\$tmp[0-9]*_.*"
                },
                "Exclude EventLog": {
                    "glob": "*eventlog.xml"
                },
                "Exclude GameGemsCode": {
                    "glob": "Gem/Code/*"
                },
                "Exclude GameGemsResources": {
                    "glob": "Gem/Resources/*"
                },
                "Exclude Private Certs": {
                    "glob": "*DynamicContent/Certificates/Private*"
                },
                "Exclude CMakeLists": {
                    "glob": "*CMakeLists.txt"
                },
                "Exclude CMakeFiles": {
                    "glob": "*.cmake"
                },
                "Exclude User": {
                    "glob": "user/*"
                },
                "Exclude Build": {
                    "glob": "build/*"
                },
                "Exclude Install": {
                    "glob": "install/*"
                },
                "Exclude ProjectPackages": {
                    "glob": "ProjectPackages/*"
                },
                // Exclude Gems inside Projects, their Assets folders will still be included
                "Exclude Gems": {
                    "glob": "Gems/*"
                },
                // Exclude the .git folder which is commonly found in projects
                "Exclude Git": {
                    "glob": ".git/*"
                },

                //------------------------------------------------------------------------------
                // Copying Files Automatically Into the Cache
                //------------------------------------------------------------------------------

                // The below section is used to register patterns (*.something) to copy into the cache
                // the "params" block must either be "copy" (copy the file) or "skip" (used for per-platfrom skipping)

                // note that productAssetType is a means of setting the output asset Type (as in AZ::Data::AssetType) of a simple job
                // and is the recommended way to specify that a certain kind of file (such as '*.myextension') becomes registered as the
                // actual UUID of that type in the engine itself.

                // globs ("*.txt") are usually faster to match (CPU wise) and easier for humans to understand than patterns.

                // Use a regex for matching files, same params for all platforms
                // "RC TGAs": {
                //  "pattern": ".+\\\\.tga$",
                //  "params": "copy"
                //}

                // Example Use a glob instead of a regex, skip the copy for the "server" platform
                // "RC TIFFs": {
                //  "glob": "*.tif",
                //  "params": "copy",
                //  "server": "skip"
                //}

                // You can also modify a version to compile all matching files again
                // By default the version is empty
                // "RC tif": {
                //  "glob": "*.tif",
                //  "params": "copy",
                //  "version": 1.0
                //}
                // This will make the AssetProcessor compile all the .tif files again if version changes.

                // you can also optionally supply a priority.
                // this is used to sort jobs when no other external circumstance sorts them (higher wins, default is 0)

                // note that the FULL PATH to the file will be used as the match, not the relative path
                // so ensure start your patterns with .* or as appropriate.
                // Also, any rules which match will apply - so if you have two rules which both apply to PNG files for example
                // but you only want one, you might want to use exclusion patterns:

                //Example: copy everything EXCEPT the ones in the libs/ui
                // "RC png-normal": {
                //  "pattern": "(?!.*libs\\\\/ui\\\\/).*\\.png",
                //  "params": "copy"
                //}

                //Example:  Process everything in the libs/ui folder
                // "RC png-ui": {
                //  "pattern": "(.*libs\\\\/ui\\\\/).*\\.png",
                //  "params": "copy"
                //}

                // More example Regexes:
                // "pattern": "(?!(.*libs\\\\/ui\\\\/)|(.*editor\\\\/).*\\\\.png"
                // This pattern will not match anything with editor/ or libs/ui/ in it
                // "pattern": "((.*libs\\\\/ui\\\\/)|(.*editor\\\\/).*\\\\.png"
                // This pattern will only match anything with editor/ or libs/ui/ in it

                // This is a JSON object - every entry must start with "RC" but make sure
                // to give every entry its own unique Name or else they will overwrite each other:
                "RC mp4": {
                    "glob": "*.mp4",
                    "params": "copy",
                    "productAssetType": "{DDFEE0B2-9E5A-412C-8C77-AB100E24C1DF}"
                },
                "RC mkv": {
                    "glob": "*.mkv",
                    "params": "copy",
                    "productAssetType": "{DDFEE0B2-9E5A-412C-8C77-AB100E24C1DF}"
                },
                "RC webm": {
                    "glob": "*.webm",
                    "params": "copy",
                    "productAssetType": "{DDFEE0B2-9E5A-412C-8C77-AB100E24C1DF}"
                },
                "RC mov": {
                    "glob": "*.mov",
                    "params": "copy",
                    "productAssetType": "{DDFEE0B2-9E5A-412C-8C77-AB100E24C1DF}"
                },
                "RC bk2": {
                    "glob": "*.bk2",
                    "params": "copy",
                    "productAssetType": "{BF4879B9-B893-41D2-80E9-24A7BDCD2B50}"
                },
                "RC img": {
                    "glob": "*.img",
                    "params": "copy"
                },
                "RC surfaceTagNameList": {
                    "glob": "*.surfaceTagNameList",
                    "params": "copy",
                    "productAssetType": "{A471B2A9-85FC-4993-842D-1881CBC03A2B}"
                },
                "RC gradImageSettings": {
                    "glob": "*.gradimagesettings",
                    "params": "copy",
                    "productAssetType": "{B36FEB5C-41B6-4B58-A212-21EF5AEF523C}"
                },
                "RC png-entityicon": {
                    "pattern": "(.*EntityIcons\\\\/).*\\\\.png",
                    "productAssetType": "{3436C30E-E2C5-4C3B-A7B9-66C94A28701B}",
                    "params": "skip",
                    "tools": "copy"
                },
                "RC usm": {
                    "glob": "*.usm",
                    "params": "copy",
                    "server": "skip"
                },
                "RC animevents": {
                    "glob": "*.animevents",
                    "params": "copy",
                    "productAssetType": "{C1D209C1-F81A-4586-A34E-1615995F9F3F}",
                    "version": 2
                },
                "RC bspace": {
                    "glob": "*.bspace",
                    "params": "copy"
                },
                "RC comb": {
                    "glob": "*.comb",
                    "params": "copy"
                },
                "RC dlg": {
                    "glob": "*.dlg",
                    "params": "copy"
                },
                "RC csv": {
                    "glob": "*.csv",
                    "params": "copy"
                },
                "RC json": {
                    "glob": "*.json",
                    "params": "copy"
                },
                "RC lmg": {
                    "glob": "*.lmg",
                    "params": "copy"
                },
                "RC smtl": {
                    "glob": "*.smtl",
                    "params": "copy"
                },
                "RC sub": {
                    "glob": "*.sub",
                    "params": "copy",
                    "productAssetType": "{71F9D30E-13F7-40D6-A3C9-E5358004B31F}",
                    "version": 2
                },
                "RC sbsar": {
                    "glob": "*.sbsar",
                    "params": "copy"
                },
                "RC loc.agsxml": {
                    "glob": "*.loc.agsxml",
                    "params": "copy",
                    "version": 1
                },
                "RC node": {
                    "glob": "*.node",
                    "params": "copy"
                },
                "RC veg": {
                    "glob": "*.veg",
                    "params": "copy"
                },
                "RC dat": {
                    "glob": "*.dat",
                    "params": "copy"
                },
                "RC lut": {
                    "glob": "*.lut",
                    "params": "copy"
                },
                "RC txt": {
                    "pattern": "^(?!.*PreloadLibs.txt).*\\\\.txt",
                    "params": "copy"
                },
                "RC cal": {
                    "glob": "*.cal",
                    "params": "copy"
                },
                "RC grp": {
                    "glob": "*.grp",
                    "params": "copy",
                    "productAssetType": "{7629EDD3-A361-49A2-B271-252127097D81}",
                    "version": 2
                },
                "RC xls": {
                    "glob": "*.xls",
                    "params": "copy"
                },
                "RC ini": {
                    "glob": "*.ini",
                    "params": "copy"
                },
                "RC ttf": {
                    "glob": "*.ttf",
                    "params": "copy"
                },
                "RC otf": {
                    "glob": "*.otf",
                    "params": "copy"
                },
                "RC ext": {
                    "glob": "*.ext",
                    "params": "copy"
                },
                // Copy all pak files except level.pak, level.pak has its own builder.
                "RC pak": {
                    "pattern": "^((?!\\\\/level\\\\.pak).)*\\\\.pak$",
                    "params": "copy"
                },
                "RC ctc": {
                    "glob": "*.ctc",
                    "params": "copy"
                },
                "RC uiprefab": {
                    "glob": "*.uiprefab",
                    "params": "copy",
                    "server": "skip"
                },
                "RC sprite": {
                    "glob": "*.sprite",
                    "params": "copy",
                    "server": "skip"
                },
                "RC bin": {
                    "glob": "*.bin",
                    "params": "copy"
                },
                "RC inputbindings": {
                    "glob": "*.inputbindings",
                    "params": "copy",
                    "productAssetType": "{25971C7A-26E2-4D08-A146-2EFCC1C36B0C}"
                },
                "RC ocm": {
                    "glob": "*.ocm",
                    "params": "copy"
                },
                // Feature tests use the raw .tif files for the golden image comparison
                "RC goldenimages": {
                    "pattern": ".*GoldenImages\\\\/.*\\\\.tif",
                    "params": "copy",
                    "server": "skip"
                },
                // Copy over certificates for use with FileDataSource
                "RC CertificatePEM": {
                    "glob": "*.pem",
                    "params": "copy"
                },
                // Copy over certificates for use with Dynamic Content
                "RC CertificateDER": {
                    "glob": "*.der",
                    "params": "copy"
                },
                "RC filetag": {
                    "glob": "*.filetag",
                    "params": "copy",
                    "productAssetType": "{F3BE5CAB-85B7-44B7-9495-863863F6B267}"
                },
                // Precompiled shader variant
                "RC azshadervariant": {
                    "glob": "*.azshadervariant",
                    "params": "copy",
                    "productAssetType": "{51BED815-36D8-410E-90F0-1FA9FF765FBA}"
                }
            }
        }
    }
}