unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/records/manage-asset/enum-records.js

@@ -1,38 +0,0 @@
-import { arr, bool, DESTRUCTIVE, DESTRUCTIVE_POLICY, ex, LOW, MEDIUM, NON_IDEMPOTENT, num, READ, READ_POLICY, r, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const ENUM_PATH = str('Asset path of the UserDefinedEnum (e.g. /Game/Enums/E_MyEnum).');
-const VALUE_NAME = str('Enum value (entry) name.');
-const SAVE = bool('Persist the enum asset to disk. Defaults to true; pass false to keep the change in memory only.');
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const E = '/Game/Enums/E_WeaponType';
-const DONE = { success: true };
-export const ENUM_RECORDS = [
-    r('create_enum', 'enum', 'Create a new UserDefinedEnum asset.', schema({ name: str('Enum name.'), path: str('Package path.'), enumPath: ENUM_PATH, values: arr('Initial enum value names.'), save: SAVE }, [], ['name', 'enumPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Create a weapon-type enum', { name: 'E_WeaponType', path: '/Game/Enums', values: ['Melee', 'Ranged', 'Thrown'] }, DONE)],
-        whenToUse: ['A new Blueprint enum is needed for a fixed set of named choices; pass values for its entries. It is saved unless save is false.'],
-        whenNotToUse: ['A group of typed fields is needed rather than a list of names (use struct.edit_struct).'] }),
-    r('delete_enum', 'enum', 'Delete a UserDefinedEnum asset.', schema({ enumPath: ENUM_PATH }, ['enumPath']), OK, { ...DESTRUCTIVE, longRunning: false }, DESTRUCTIVE_POLICY, LOW, { examples: [ex('Delete an obsolete enum', { enumPath: '/Game/Enums/E_Deprecated' }, DONE)],
-        whenToUse: ['An obsolete enum asset must be deleted from the project; a blocked delete is reported as DELETE_FAILED.'],
-        whenNotToUse: ['Assets that still use the enum must be found first (use asset.inspect_asset with lookup=dependencies and referencers=true).', 'The enum should be renamed or moved, not deleted (use asset.rename).'] }),
-    r('get_enum', 'enum', 'Read a Blueprint enum (UserDefinedEnum): every entry with its name and numeric value, plus the value count.', schema({ enumPath: ENUM_PATH }, ['enumPath']), OK, READ, READ_POLICY, LOW, { topics: ['entry names and values', 'list entries', 'show enum values'], examples: [ex('Read an enum\'s values', { enumPath: E }, DONE)],
-        whenToUse: ['The current entries of an enum, with their exact names and numeric values, must be read before any edit that names an entry.', 'An enum must be checked after an edit: its entries, numeric values and entry count.'],
-        whenNotToUse: ['An enum must be changed rather than read (use enum.edit_enum).', 'The enum asset must be found by name first (use asset.query_asset).'] }),
-    r('add_enum_value', 'enum', 'Add a new value to a UserDefinedEnum.', schema({ enumPath: ENUM_PATH, valueName: VALUE_NAME, save: SAVE }, ['enumPath', 'valueName']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Add a new weapon type', { enumPath: E, valueName: 'Explosive' }, DONE)],
-        whenToUse: ['One more named entry must be appended to the end of an existing enum.'],
-        whenNotToUse: ['The existing entries must only be read (use enum.get_enum).'] }),
-    r('remove_enum_value', 'enum', 'Remove a value from a UserDefinedEnum.', schema({ enumPath: ENUM_PATH, valueName: VALUE_NAME, save: SAVE }, ['enumPath', 'valueName']), OK, { ...DESTRUCTIVE, longRunning: false }, DESTRUCTIVE_POLICY, LOW, { examples: [ex('Remove an unused weapon type', { enumPath: E, valueName: 'Thrown' }, DONE)],
-        whenToUse: ['One entry must be dropped from an enum; the entries after it are renumbered.'],
-        whenNotToUse: ['An entry only needs a new name (use enum.edit_enum).'] }),
-    r('rename_enum_value', 'enum', 'Rename a value in a UserDefinedEnum.', schema({ enumPath: ENUM_PATH, valueName: VALUE_NAME, newValueName: str('New enum value name.'), save: SAVE }, ['enumPath', 'valueName', 'newValueName']), OK, NON_IDEMPOTENT, WRITE_POLICY, LOW, { examples: [ex('Rename Ranged to Firearm', { enumPath: E, valueName: 'Ranged', newValueName: 'Firearm' }, DONE)],
-        whenToUse: ['An enum entry needs a new name while keeping its place in the order.'],
-        whenNotToUse: ['An entry must be dropped, not renamed (use enum.delete_enum with deleteScope=value).'] }),
-    r('reorder_enum_values', 'enum', 'Reorder values in a UserDefinedEnum.', schema({ enumPath: ENUM_PATH, order: arr('Desired value name order.'), save: SAVE }, ['enumPath', 'order']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Put ranged weapons first', { enumPath: E, order: ['Ranged', 'Melee', 'Thrown'] }, DONE)],
-        whenToUse: ['The order of entries must change; the order list must name every current value and numeric values follow the new order.'],
-        whenNotToUse: ['The current order must be checked before reordering (use enum.get_enum).'] }),
-    r('set_enum_value_metadata', 'enum', 'Set metadata (tooltip, etc.) on an enum value.', schema({ enumPath: ENUM_PATH, valueName: VALUE_NAME, key: str('Metadata key.'), value: { description: 'Metadata value.' }, save: SAVE }, ['enumPath', 'valueName', 'key']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Document a value with a tooltip', { enumPath: E, valueName: 'Melee', key: 'ToolTip', value: 'Close-quarters weapon.' }, DONE)],
-        whenToUse: ['A metadata key such as ToolTip must be stored against one enum entry.'],
-        whenNotToUse: ['Metadata for a struct field is wanted (use struct.edit_struct).'] }),
-    r('split_enum', 'enum', 'Split a UserDefinedEnum into a new enum with selected values.', schema({ enumPath: ENUM_PATH, newEnumName: str('Name for the new enum.'), values: arr('Value names to copy into the new enum. Pass this or index.'), index: num('Split position: every value from this zero-based index on is copied into the new enum. Pass this or values.'), path: str('Package path for the new enum.'), save: SAVE }, ['enumPath', 'newEnumName']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Split thrown weapons into their own enum', { enumPath: E, newEnumName: 'E_ThrownType', values: ['Thrown'] }, DONE)],
-        whenToUse: ['Chosen entries must be copied into a new enum, by name or from an index on; the source enum is left unchanged.'],
-        whenNotToUse: ['The chosen entries must also leave the source enum, which a split does not do (use enum.delete_enum with deleteScope=value).'] })
-];
-//# sourceMappingURL=enum-records.js.map

package/dist/tools/catalog/capabilities/records/manage-asset/index.d.ts

@@ -1,6 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-import type { RecordSpec } from './builder.js';
-export declare const MANAGE_ASSET_RECORD_SPECS: readonly RecordSpec[];
-export declare const MANAGE_ASSET_UNFOLDED_SOURCES: readonly CapabilityRecordSource[];
-export declare const MANAGE_ASSET_SOURCES: readonly CapabilityRecordSource[];
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-asset/index.js

@@ -1,27 +0,0 @@
-import { CapabilityRecordSourceSchema } from '../../record-schema.js';
-import { MANAGE_ASSET_FOLDS } from '../folds/manage-asset.folds.js';
-import { applyFolds } from '../shared/fold.js';
-import { ASSET_ADVANCED_RECORDS } from './asset-advanced.js';
-import { ASSET_LIFECYCLE_RECORDS } from './asset-lifecycle.js';
-import { ASSET_QUERY_RECORDS } from './asset-query.js';
-import { toSource } from './builder.js';
-import { CONTENT_SOURCE_RECORDS } from './content-sources.js';
-import { DATATABLE_RECORDS } from './datatable-records.js';
-import { ENUM_RECORDS } from './enum-records.js';
-import { MATERIAL_CREATE_RECORDS } from './material-create.js';
-import { MATERIAL_GRAPH_RECORDS } from './material-graph.js';
-import { MATERIAL_NODES_RECORDS } from './material-nodes.js';
-import { MATERIAL_PARAMS_RECORDS } from './material-params.js';
-import { STRUCT_RECORDS } from './struct-records.js';
-import { TEXTURE_ADJUST_RECORDS } from './texture-adjust.js';
-import { TEXTURE_CONFIG_RECORDS } from './texture-config.js';
-import { TEXTURE_CREATE_RECORDS } from './texture-create.js';
-export const MANAGE_ASSET_RECORD_SPECS = [
-    ...ASSET_LIFECYCLE_RECORDS, ...CONTENT_SOURCE_RECORDS, ...ASSET_QUERY_RECORDS, ...ASSET_ADVANCED_RECORDS,
-    ...MATERIAL_CREATE_RECORDS, ...MATERIAL_NODES_RECORDS, ...MATERIAL_GRAPH_RECORDS, ...MATERIAL_PARAMS_RECORDS,
-    ...TEXTURE_CREATE_RECORDS, ...TEXTURE_ADJUST_RECORDS, ...TEXTURE_CONFIG_RECORDS,
-    ...STRUCT_RECORDS, ...DATATABLE_RECORDS, ...ENUM_RECORDS
-];
-export const MANAGE_ASSET_UNFOLDED_SOURCES = MANAGE_ASSET_RECORD_SPECS.map((spec) => CapabilityRecordSourceSchema.parse(toSource(spec)));
-export const MANAGE_ASSET_SOURCES = applyFolds(MANAGE_ASSET_UNFOLDED_SOURCES, MANAGE_ASSET_FOLDS, 'manage_asset');
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/manage-asset/material-create.d.ts

@@ -1,3 +0,0 @@
-import type { RecordSpec } from './builder.js';
-export declare const MATERIAL_CREATE_RECORDS: readonly RecordSpec[];
-//# sourceMappingURL=material-create.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-asset/material-create.js

@@ -1,57 +0,0 @@
-import { arrObj, BLEND_MODE, bool, ex, MATERIAL_DOMAIN, MATERIAL_PARAMETER_LIST, MEDIUM, r, SHADING_MODEL, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const SAVE = bool('Save the asset afterwards. Defaults to true; pass false to keep it in memory only.');
-const PRESET_SETTINGS = {
-    materialDomain: str('Material domain; overrides the preset domain.'),
-    blendMode: str('Blend mode; overrides the preset blend mode.'),
-    shadingModel: str('Shading model.'),
-    twoSided: bool('Two-sided flag.'),
-    save: SAVE,
-};
-const OK_PROPS = { success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } };
-const OK = schema(OK_PROPS, ['success']);
-export const MATERIAL_CREATE_RECORDS = [
-    r('create_material', 'material', 'Create a new material asset.', schema({ name: str('Asset name.'), path: str('Package path.'), materialDomain: MATERIAL_DOMAIN, blendMode: BLEND_MODE, shadingModel: SHADING_MODEL, twoSided: bool('Two-sided flag.'), save: SAVE }, ['name']), OK, WRITE, WRITE_POLICY, MEDIUM, { whenToUse: ['A mesh, surface or effect needs a shader of its own and no material asset exists for it yet.', 'A translucent, unlit or two-sided material is wanted from the start (materialDomain, blendMode, shadingModel, twoSided).'],
-        whenNotToUse: ['A variation of an existing material with different parameter values is wanted (use material.create_material_instance).', 'An existing material must be copied as it is (use asset.duplicate).'],
-        topics: ['new material', 'make material', 'material asset', 'shader'],
-        examples: [ex('Create an opaque lit surface material', { name: 'M_Base', path: '/Game/Materials', materialDomain: 'Surface', blendMode: 'Opaque', shadingModel: 'DefaultLit', twoSided: false, save: true }, { success: true })] }),
-    r('create_material_instance', 'material', 'Create a material instance from a parent material, optionally with its parameter values already set, or several instances (a palette) under one consent.', schema({
-        name: str('Instance name.'), parentMaterial: str('Parent material /Game path.'), savePath: str('Package path for the instance.'), parameters: MATERIAL_PARAMETER_LIST, save: SAVE,
-        instances: {
-            type: 'array', minItems: 1, maxItems: 64, items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true,
-            description: 'Several instances in one call, in place of name: each {name, and any of parentMaterial, savePath, parameters, save}; the call\'s own parentMaterial, savePath and save are every entry\'s defaults. Every entry is reported under instances; the call fails naming any that were not created.',
-        },
-    }, [], ['name', 'instances']), schema({ ...OK_PROPS, instances: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'With instances: one entry per instance in order: name, success, error and errorCode when it failed, and what a single create reports (assetPath, parameters).' }, created: { type: 'number', description: 'With instances: how many were created.' } }, ['success']), WRITE, WRITE_POLICY, MEDIUM, { whenToUse: ['A variation of a base material is needed with new parameter values and no second node graph.', 'An instance should start with scalar, vector or texture overrides already applied (pass parameters).', 'A palette of instances of one parent must be made at once (instances), under one consent instead of one per instance.'],
-        whenNotToUse: ['The material needs its own node graph (use material.create_material).', 'An existing instance needs new values (use material.set_material_parameter); the parent must be a base material, not another instance.'],
-        topics: ['material instance', 'mi', 'instance material', 'child material', 'make material instance', 'material palette', 'several material instances'], dispatchAction: 'create_material_instance',
-        examples: [ex('Instance a base material', { name: 'MI_Base_Rusty', parentMaterial: '/Game/Materials/M_Base', savePath: '/Game/Materials' }, { success: true }),
-            ex('Make a palette of instances under one consent', { parentMaterial: '/Game/Materials/M_Toy', savePath: '/Game/Materials/Instances', instances: [{ name: 'MI_Toy_Red', parameters: [{ parameterName: 'Color', parameterType: 'vector', value: [0.8, 0.1, 0.1] }] }, { name: 'MI_Toy_Blue', parameters: [{ parameterName: 'Color', parameterType: 'vector', value: [0.1, 0.2, 0.8] }] }] }, { success: true, created: 2 })] }),
-    r('create_material_function', 'material', 'Create a new material function asset.', schema({ name: str('Function name.'), path: str('Package path.'), save: SAVE, description: str('Function description.'), exposeToLibrary: bool('Expose in the material function library.') }, ['name']), OK, WRITE, WRITE_POLICY, MEDIUM, { whenToUse: ['A chunk of graph logic must be reused by several materials as one node, listed in the function library unless exposeToLibrary is false.'],
-        whenNotToUse: ['The logic is used by one material only (build it in that material with material.add_material_node).'],
-        examples: [ex('Create a reusable blend function', { name: 'MF_HeightBlend', path: '/Game/Materials/Functions', save: true }, { success: true })] }),
-    r('create_parameter_collection', 'material', 'Create a Material Parameter Collection, values every material that reads it shares, or add parameters to one and set their defaults.', schema({
-        name: str('Asset name.'), path: str('Package path.'), save: SAVE,
-        scalars: arrObj('Scalar parameters, each {name, default}: a name the collection lacks is added, one it has takes the new default (0 when a new one gives none).'),
-        vectors: arrObj('Vector parameters, each {name, default}: default as [r, g, b, a] or {r, g, b, a} (alpha 1 when omitted); a name the collection lacks is added, one it has takes the new default.'),
-    }, ['name']), schema({
-        ...OK_PROPS,
-        assetPath: str('The collection\'s object path.'), created: bool('True when the call made the collection, false when it updated one.'),
-        added: { type: 'array', items: { type: 'string' }, description: 'The parameters this call added.' },
-        scalars: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'Every scalar parameter of the collection after the call: {name, default}.' },
-        vectors: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'Every vector parameter after the call: {name, default [r, g, b, a]}.' },
-        saved: bool('Whether the collection reached disk.'),
-    }, ['success']), WRITE, WRITE_POLICY, MEDIUM, { whenToUse: ['One value must drive many materials at once, set once at runtime (a level-wide wetness, wind strength, time of day or flash): a material reads it with a CollectionParameter node (material.add_material_node nodeType CollectionParameter with collectionPath and name), and a Blueprint sets it with SetScalarParameterValue or SetVectorParameterValue of the Kismet Material Library, the collection on its Collection pin.', 'An existing collection needs another parameter or new defaults: send it again; parameters are never removed, since materials read them by id.'],
-        whenNotToUse: ['The value differs per object (use a material instance and material.set_material_parameter, or a dynamic material instance per actor).'],
-        topics: ['material parameter collection', 'mpc', 'global material parameter', 'shared material value', 'level wide material value'],
-        examples: [ex('A collection for level-wide weather', { name: 'MPC_Weather', path: '/Game/Materials', scalars: [{ name: 'Wetness', default: 0 }, { name: 'WindStrength', default: 0.3 }], vectors: [{ name: 'FogTint', default: [0.6, 0.7, 0.8, 1] }] }, { success: true, assetPath: '/Game/Materials/MPC_Weather.MPC_Weather', created: true, added: ['Wetness', 'WindStrength', 'FogTint'], saved: true })] }),
-    r('create_landscape_material', 'material', 'Create a landscape material asset (Surface domain, Opaque by default).', schema({ name: str('Material name.'), path: str('Package path.'), ...PRESET_SETTINGS }, ['name']), OK, WRITE, WRITE_POLICY, MEDIUM, { whenToUse: ['A material is being made for a landscape; it starts empty (Surface domain, Opaque) and its layers are added afterwards.'],
-        whenNotToUse: ['The material exists and only needs assigning to a landscape (use build_environment.sculpt with sculptOp=material).'],
-        examples: [ex('Create a terrain material', { name: 'M_Landscape', path: '/Game/Materials/Landscape' }, { success: true })] }),
-    r('create_decal_material', 'material', 'Create a decal material asset (DeferredDecal domain, Translucent by default).', schema({ name: str('Material name.'), path: str('Package path.'), ...PRESET_SETTINGS }, ['name']), OK, WRITE, WRITE_POLICY, MEDIUM, { whenToUse: ['A material is needed to project onto surfaces as a deferred decal, such as scorch marks or stains.'],
-        whenNotToUse: ['A decal material already exists and only its blend mode must change (use material.set_material_property).'],
-        examples: [ex('Create a decal material', { name: 'M_Decal_Scorch', path: '/Game/Materials/Decals' }, { success: true })] }),
-    r('create_post_process_material', 'material', 'Create a post-process material asset (PostProcess domain by default).', schema({ name: str('Material name.'), path: str('Package path.'), ...PRESET_SETTINGS }, ['name']), OK, WRITE, WRITE_POLICY, MEDIUM, { whenToUse: ['A full-screen effect such as a vignette or color grade needs a post-process domain material.'],
-        whenNotToUse: ['A built-in post-process setting such as bloom or exposure is enough (use build_environment.configure_post_process).'],
-        examples: [ex('Create a vignette post-process material', { name: 'M_PP_Vignette', path: '/Game/Materials/PostProcess' }, { success: true })] })
-];
-//# sourceMappingURL=material-create.js.map

package/dist/tools/catalog/capabilities/records/manage-asset/material-graph.d.ts

@@ -1,3 +0,0 @@
-import type { RecordSpec } from './builder.js';
-export declare const MATERIAL_GRAPH_RECORDS: readonly RecordSpec[];
-//# sourceMappingURL=material-graph.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-asset/material-graph.js

@@ -1,152 +0,0 @@
-import { arr, arrObj, bool, ex, LOW, MATERIAL_PARAMETER_ASSETS, MATERIAL_PARAMETER_LIST, num, READ, READ_POLICY, r, refObj, str, WRITE, WRITE_POLICY } from './builder.js';
-import { OUTPUT_HEADER, schema } from '../shared/record-presets.js';
-const MAT = str('Material /Game asset path.');
-const MAT_ALIAS = str('Material asset path (accepted in place of materialPath).');
-const SOURCE_PIN = str('Source output: its name, its index, or channel letters of the default output ("G", "RG"; X/Y/Z/W work too). Omit for the default output.');
-const TARGET_PIN = str('Target pin name. On the material output (targetNodeId Main): BaseColor, Metallic, Specular, Roughness, Anisotropy, EmissiveColor, Opacity, OpacityMask, Normal, Tangent, WorldPositionOffset, SubsurfaceColor, ClearCoat, ClearCoatRoughness, AmbientOcclusion, Refraction, PixelDepthOffset (and SurfaceThickness, Displacement on newer engines); a Cloth material\'s Cloth and FuzzColor, and CustomData0/CustomData1, name the clear-coat and subsurface pins they share.');
-const SAVE = bool('Save the asset afterwards. Defaults to true; pass false to keep the change in memory only.');
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const MOVE_OUT = schema({
-    success: bool('Operation succeeded.'),
-    details: OUTPUT_HEADER.details,
-    nodeId: str('Moved node ID.'),
-    posX: num('X coordinate the node now sits at.'),
-    posY: num('Y coordinate the node now sits at.'),
-    estimatedWidth: num('Approximate node width; an estimate, not a measurement.'),
-    estimatedHeight: num('Approximate node height from connector count plus the inline default-value widget allowance.'),
-    overlappingNodes: { type: 'array', items: { type: 'string' }, description: 'Names of expressions still overlapping after the move. Absent when the placement is clear.' },
-    placementWarning: str('Human-readable overlap warning, present only when overlappingNodes is non-empty.'),
-}, ['success']);
-const CONNECTIONS_OUT = schema({
-    success: bool('Operation succeeded.'),
-    nodeId: str('Node the traversal started from.'),
-    type: str('Expression class name of the start node.'),
-    connectionCount: num('Number of connections returned.'),
-    connections: arrObj('Edges found, each with sourceNodeId, sourceOutputIndex, targetNodeId, targetInput, hop and direction. A targetNodeId of "Main" is the material output node.'),
-}, ['success']);
-const NODE_DETAILS_OUT = schema({
-    success: bool('Operation succeeded.'),
-    nodeId: str('Resolved node ID.'),
-    nodeType: str('Expression class name.'),
-    nodeName: str('Expression object name.'),
-    assetType: str('Material or MaterialFunction.'),
-    parameterName: str('Parameter name, for parameter expressions.'),
-    scalarDefault: num('DefaultValue, for scalar parameter expressions.'),
-    vectorDefault: refObj('DefaultValue as rgba, for vector parameter expressions.'),
-    inputName: str('Pin name, for a function input.'),
-    inputType: str('Pin type, for a function input.'),
-    outputName: str('Pin name, for a function output.'),
-    sortPriority: num('Pin sort priority, for function input/output expressions.'),
-    usePreviewValueAsDefault: bool('Whether a function input previews its default.'),
-}, ['success']);
-const OPERATIONS = {
-    type: 'array',
-    items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-    'x-unreal-reflection-boundary': true,
-    description: 'Steps run in order, 1-200. Each is {edit, ...the params of that edit}: edit is a node adder (add_material_node, '
-        + 'add_scalar_parameter, add_vector_parameter, add_texture_sample, add_texture_coordinate, add_math_node, add_noise, '
-        + 'add_custom_expression, ...; or add_material_node with nodeKind, as in the single call: {"edit": "add_material_node", '
-        + '"nodeKind": "world_position"}), use_material_function, connect_nodes, set_node_position, update_custom_expression, '
-        + 'set_blend_mode, set_shading_model, set_material_domain or set_two_sided. Optional per step: id (names the created '
-        + 'node; later steps use "$id" in sourceNodeId/targetNodeId/nodeId), from/to ("$id.Pin" shorthand for connect_nodes, where '
-        + 'a source pin may be channel letters like "$uv.G"; '
-        + '"Main.EmissiveColor" is the material output). A created node without x/y is laid out automatically. Deleting and '
-        + 'disconnecting are not batched. The batch stops at the first failing step; when every step ran, the material is '
-        + 'compiled and saved once.',
-};
-const BATCH_OUT = schema({
-    success: bool('True when every step ran.'),
-    assetPath: str('The material the batch edited, compiled and saved.'),
-    results: arrObj('Per-step outcome: index, edit, id, success, nodeId, placementWarning, error. A step that ran and has nothing more to say (a plain connect_nodes) is counted in succeeded, not listed; a failed batch lists every step.'),
-    nodeIds: { type: 'object', additionalProperties: { type: 'string' }, description: 'Step id -> node id for every node the batch created.' },
-    succeeded: num('Steps that completed.'),
-    failedIndex: num('Index of the step that stopped the batch (failures only).'),
-    compiled: bool('False when the material does not compile after the batch; compileErrors says why.'),
-    compileErrors: arr('Compile errors after the batch, empty when the material compiles.'),
-    saved: bool('Whether the material was saved after the batch.'),
-}, ['success']);
-const CUSTOM_UPDATE_OUT = schema({
-    success: bool('Operation succeeded.'),
-    compiled: bool('False when the material does not compile after the edit (the default material renders in its place); compileErrors says why. A material function has no translation of its own to read, so this is true for one.'),
-    compileErrors: arr('Compile errors after the edit, from the material translator and, once it has finished, the shader compile (where a Custom node\'s HLSL fails); empty when it compiles.'),
-    saved: bool('Whether the material or function was saved after the edit.'),
-    details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' },
-}, ['success']);
-const M = '/Game/Materials/M_Base';
-const SAMPLE = 'MaterialExpressionTextureSample_0';
-const MULTIPLY = 'MaterialExpressionMultiply_0';
-const DONE = { success: true };
-export const MATERIAL_GRAPH_RECORDS = [
-    r('connect_nodes', 'material', 'Connect two nodes in a material graph.', schema({ materialPath: MAT, assetPath: str('Material asset path (accepted in place of materialPath).'), sourceNodeId: str('Source node ID.'), sourcePin: SOURCE_PIN, targetNodeId: str('Target node ID.'), targetPin: TARGET_PIN, inputName: str('Input pin name.') }, ['sourceNodeId', 'targetNodeId'], ['materialPath', 'assetPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['The output of one material node must feed an input of another node in the same material or function.', 'A node result must drive a material output such as BaseColor or Roughness (targetNodeId Main).'],
-        whenNotToUse: ['A whole graph of nodes and wires is being built (use material.add_material_node with nodeKind=batch).', 'A wire must be removed (use material.disconnect_nodes).'],
-        examples: [ex('Feed a texture sample into a multiply', { materialPath: M, sourceNodeId: SAMPLE, sourcePin: 'RGB', targetNodeId: MULTIPLY, targetPin: 'A' }, DONE)] }),
-    r('connect_material_pins', 'material', 'Connect material pins (alias of connect_nodes).', schema({ materialPath: MAT, assetPath: str('Material asset path (accepted in place of materialPath).'), sourceNodeId: str('Source node ID.'), sourcePin: SOURCE_PIN, targetNodeId: str('Target node ID.'), targetPin: TARGET_PIN }, ['sourceNodeId', 'targetNodeId'], ['materialPath', 'assetPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['The output of one material node must feed an input of another node in the same material or function.', 'A node result must drive a material output such as BaseColor or Roughness (targetNodeId Main).'],
-        whenNotToUse: ['A whole graph of nodes and wires is being built (use material.add_material_node with nodeKind=batch).', 'A wire must be removed (use material.disconnect_nodes).'],
-        dispatchAction: 'connect_material_pins', examples: [ex('Connect pins via the alias route', { materialPath: M, sourceNodeId: SAMPLE, sourcePin: 'RGB', targetNodeId: MULTIPLY, targetPin: 'A' }, DONE)] }),
-    r('disconnect_nodes', 'material', 'Disconnect two nodes in a material graph.', schema({ materialPath: MAT, nodeId: str('Node ID.'), pinName: str('Input to unplug: a pin of nodeId by name or label (a custom node input such as OB), or for nodeId Main a material output input (BaseColor, Normal...). A name that matches none fails listing the inputs; only a material function\'s output node takes none, unplugging every output.') }, ['materialPath', 'nodeId']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['The wire into one input pin of a node must be cleared while both nodes stay.', 'A material output such as BaseColor must be unplugged (nodeId Main with pinName BaseColor).'],
-        whenNotToUse: ['A node is no longer needed (use material.delete_node, which also clears every wire that used it).', 'A pin must take a different source (use material.connect_nodes, which replaces the current wire).'],
-        examples: [ex('Break the A input of a multiply', { materialPath: M, nodeId: MULTIPLY, pinName: 'A' }, DONE)] }),
-    r('find_node', 'material', 'Find a node in a material graph by type or name.', schema({ materialPath: MAT, assetPath: str('Material asset path (accepted in place of materialPath, as the sibling read actions spell it).'), nodeType: str('Node type to find.'), nodeName: str('Name to find: a node id, parameter name, function input or output name, or custom node title (substring match).') }, [], ['materialPath', 'assetPath']), OK, READ, READ_POLICY, LOW, { whenToUse: ['A node id is unknown and the node must be found by expression class, parameter name, function pin name or Custom node title.'],
-        whenNotToUse: ['The material asset itself must be located by name or class (use asset.query_asset).'],
-        examples: [ex('Locate every texture sample', { materialPath: M, nodeType: 'TextureSample' }, DONE)] }),
-    r('get_node_connections', 'material', 'Retrieve connections for a node in a material graph.', schema({ materialPath: MAT, assetPath: MAT_ALIAS, nodeId: str('Node ID.'), direction: str('Connection direction to report (inputs or outputs).'), depth: num('Traversal depth; -1 walks the whole graph.'), upstream: bool('Walk every upstream producer, overriding direction and depth.'), downstream: bool('Report downstream connections instead of upstream.') }, ['nodeId'], ['materialPath', 'assetPath']), CONNECTIONS_OUT, READ, READ_POLICY, LOW, { whenToUse: ['The wiring of a node must be traced across the graph, for example to see where its result ends up at the material output.'],
-        whenNotToUse: ['A wire must be added, cut or rerouted, not traced (use material.connect_nodes or material.disconnect_nodes).'],
-        examples: [ex('List what feeds a multiply node', { materialPath: M, nodeId: MULTIPLY, direction: 'inputs', downstream: false }, DONE)] }),
-    r('get_node_properties', 'material', 'Retrieve properties of a node in a material graph.', schema({ materialPath: MAT, assetPath: MAT_ALIAS, nodeId: str('Node ID.') }, ['nodeId'], ['materialPath', 'assetPath']), OK, READ, READ_POLICY, LOW, { whenToUse: ['The settings of one node must be read back, such as a scalar or vector parameter default or a function input or output pin.'],
-        whenNotToUse: ['A parameter value or Custom node code must change, not be read (use material.set_material_parameter or material.update_custom_expression).', 'Any other property of a node must change, such as the Texture or SamplerType of a texture parameter (use inspect.set_property with objectPath "<material path>.<material name>:<nodeId>").'],
-        examples: [ex('Read a texture sample node\'s properties', { materialPath: M, nodeId: SAMPLE }, DONE)] }),
-    r('set_static_switch_parameter_value', 'material', 'Set a static switch parameter value on a material instance.', schema({ assetPath: str('Material instance /Game asset path.'), parameterName: str('Parameter name.'), value: bool('Switch value.'), save: SAVE }, ['assetPath', 'parameterName', 'value']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A static switch parameter must be turned on or off; on an instance this rebuilds the shader permutation.'],
-        whenNotToUse: ['The parameter is not on the base material yet (add it there with asset.edit_material_instance edit=add_parameter or material.add_material_node).'],
-        examples: [ex('Enable a detail-map switch on an instance', { assetPath: '/Game/Materials/MI_Base_Rusty', parameterName: 'UseDetailMap', value: true }, DONE)] }),
-    r('delete_node', 'material', 'Delete one node, or several with nodeIds, from a material graph; the material is recompiled and saved.', schema({ materialPath: MAT, nodeId: str('Node ID to delete.'), nodeIds: arr('Node IDs to delete in one batch, in place of nodeId.'), save: SAVE }, ['materialPath'], ['nodeId', 'nodeIds']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['An unused or wrong node must leave a material or function graph, taking its wires with it.', 'Several stray nodes must go in one call (nodeIds).'],
-        whenNotToUse: ['Only the wire to a node must be cleared while the node stays (use material.disconnect_nodes).', 'Unused nodes must be found first (use material.get_material_info with info=subgraph and orphansOnly=true).'],
-        examples: [ex('Delete an unused multiply node', { materialPath: M, nodeId: MULTIPLY }, DONE)] }),
-    r('update_custom_expression', 'material', 'Update a custom expression node: its HLSL code, inputs, output type, additional outputs or title. An input that keeps its name keeps its wire. The material is then compiled and saved, and compiled, compileErrors and saved in the reply say how that went (a step of build_material_graph leaves both to the batch).', schema({ materialPath: MAT, nodeId: str('Node ID.'), code: str('Updated HLSL code.'), inputs: arrObj('Replacement input list, each {name}; inputs whose names stay keep their connections.'), outputType: str('Output type: Float1, Float2, Float3, Float4 or MaterialAttributes.'), description: str('Node title shown in the material editor.'), additionalOutputs: arrObj('Extra output pins after the return value, each {name, type}: type Float1 (default), Float2, Float3, Float4 or MaterialAttributes. Assign each by name in the HLSL (Emis = ...;) and wire it as "$node.Name".') }, ['materialPath', 'nodeId', 'code']), CUSTOM_UPDATE_OUT, WRITE, WRITE_POLICY, LOW, { topics: ['edit shader code', 'custom hlsl code'],
-        whenToUse: ['The HLSL code of an existing Custom node must be rewritten without rebuilding its wiring.', 'Inputs, output type, extra outputs or the title of a Custom node must change; inputs that keep their name keep their wire.'],
-        whenNotToUse: ['A new Custom node is needed (use material.add_material_node with nodeKind=custom_expression).', 'The node is a parameter or any other non-Custom expression; only Custom nodes are accepted (parameter values use material.set_material_parameter).'],
-        examples: [ex('Rewrite a custom node\'s HLSL', { materialPath: M, nodeId: 'MaterialExpressionCustom_0', code: 'return saturate(A * 3.0f);' }, DONE)] }),
-    r('get_node_chain', 'material', 'Retrieve the chain of nodes connected to a starting node.', schema({ materialPath: MAT, assetPath: MAT_ALIAS, nodeId: str('Starting node ID.'), startNodeId: str('Starting node ID accepted by the handler in place of nodeId.'), endPin: str('Terminal pin name to stop the chain walk at.') }, ['nodeId'], ['materialPath', 'assetPath']), OK, READ, READ_POLICY, LOW, { whenToUse: ['The wiring of a node must be traced across the graph, for example to see where its result ends up at the material output.'],
-        whenNotToUse: ['A wire must be added, cut or rerouted, not traced (use material.connect_nodes or material.disconnect_nodes).'],
-        examples: [ex('Walk the chain feeding BaseColor', { materialPath: M, nodeId: SAMPLE, endPin: 'BaseColor' }, DONE)] }),
-    r('get_connected_subgraph', 'material', 'Retrieve the connected subgraph from a starting node.', schema({ materialPath: MAT, assetPath: MAT_ALIAS, nodeId: str('Starting node ID.'), orphansOnly: bool('Report only orphaned nodes; accepted in place of nodeId.') }, ['nodeId'], ['materialPath', 'assetPath']), OK, READ, READ_POLICY, LOW, { whenToUse: ['Nodes not wired to any output (orphans) must be found, or the connected island around one node listed.'],
-        whenNotToUse: ['Orphaned nodes are to be removed (use material.delete_node once their ids are known).'],
-        examples: [ex('Collect the subgraph under a node', { materialPath: M, nodeId: SAMPLE, orphansOnly: false }, DONE)] }),
-    r('add_material_node', 'material', 'Add a generic material node by type.', schema({ materialPath: MAT, nodeType: str('Node type.'), type: str('Node type (alias of nodeType).'), name: str('Parameter name, when the node type is a parameter of any kind (scalar, vector, static switch, TextureObjectParameter, TextureSampleParameter2D), or the parameter of collectionPath a CollectionParameter node reads.'), collectionPath: str('Material Parameter Collection a CollectionParameter node reads (name picks its parameter); a collection that does not load, or lacks the parameter, adds nothing and fails, listing its parameters.'), texturePath: str('Texture for a texture node (TextureObjectParameter, TextureSample...): its default, with the sampler type set to match (a normal map samples as Normal). A path that does not load adds nothing and fails.'), defaultValue: { description: 'Initial value for a Constant (number) or Constant3Vector (rgb array or {r,g,b}) node.' }, posX: num('Node X position.'), posY: num('Node Y position.'), x: num('Node X position (preferred spelling; posX is the fallback).'), y: num('Node Y position (preferred spelling; posY is the fallback).') }, ['materialPath', 'nodeType']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['An expression is needed by class name with no dedicated adder, such as Constant, Constant3Vector (with defaultValue), ComponentMask or Saturate.', 'A texture object must feed a Custom node or a material function input (nodeType TextureObjectParameter with name and texturePath).', 'A material must read a value of a Material Parameter Collection (nodeType CollectionParameter with collectionPath and name).'],
-        whenNotToUse: ['The node already exists and only needs wiring or moving (use material.connect_nodes or material.set_node_position).'],
-        examples: [ex('Add a Constant3Vector by type name', { materialPath: M, nodeType: 'Constant3Vector', x: -300, y: 100 }, DONE)] }),
-    r('rebuild_material', 'material', 'Rebuild and compile a material (alias of compile_material).', schema({ materialPath: MAT, assetPath: MAT_ALIAS, save: SAVE }, [], ['materialPath', 'assetPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['The shader must be regenerated after graph edits; the compile, error check and save are identical to a plain compile.'],
-        whenNotToUse: ['A property or parameter was just set (material.set_material_property and material.set_material_parameter already recompile).'],
-        dispatchAction: 'rebuild_material', examples: [ex('Rebuild after graph edits', { materialPath: M }, DONE)] }),
-    r('set_material_parameter', 'material', 'Set a material parameter value, several at once with parameters, or the values of several material instances under one consent with assets.', schema({ assetPath: MAT, parameterName: str('Parameter name.'), parameterType: str('Parameter kind: scalar (default), vector, or texture. Selects which parameter expression the value is written to.'), value: { description: 'Parameter value.' }, texturePath: str('Texture /Game path, for parameterType texture.'), parameters: MATERIAL_PARAMETER_LIST, assets: MATERIAL_PARAMETER_ASSETS, save: SAVE }, [], ['assetPath', 'assets']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['Several parameter values on a base material or an instance must change in one call (parameters list).', 'Several material instances must be retuned at once, a palette recoloured (assets), under one consent instead of one per instance.', 'The default of a parameter node on a base material must change; on an instance the value is stored as an override.'],
-        whenNotToUse: ['The parameter is not on the base material yet (add it there with asset.edit_material_instance edit=add_parameter or material.add_material_node).', 'Every override on an instance must be cleared back to its parent (use asset.edit_material_instance edit=reset_parameters).'],
-        topics: ['material parameter', 'set parameter', 'scalar parameter', 'vector parameter', 'texture parameter', 'recolor several material instances'],
-        examples: [ex('Set a roughness parameter', { assetPath: M, parameterName: 'Roughness', value: 0.35 }, DONE),
-            ex('Retune two instances under one consent', { assets: [
-                    { assetPath: '/Game/Materials/MI_LampRed', parameters: [{ parameterName: 'Color', parameterType: 'vector', value: [1, 0.02, 0.01] }, { parameterName: 'SelfGlow', parameterType: 'scalar', value: 3.5 }] },
-                    { assetPath: '/Game/Materials/MI_LampGreen', parameterName: 'SelfGlow', value: 3.5 }
-                ] }, DONE)] }),
-    r('get_material_node_details', 'material', 'Retrieve details of a material node.', schema({ materialPath: MAT, assetPath: str('Material asset path (accepted in place of materialPath).'), nodeId: str('Node ID.'), expressionIndex: num('Zero-based position in the expression list; picks the node when nodeId is omitted.') }, [], ['materialPath', 'assetPath']), NODE_DETAILS_OUT, READ, READ_POLICY, LOW, { whenToUse: ['The settings of one node must be read back, such as a scalar or vector parameter default or a function input or output pin.'],
-        whenNotToUse: ['A parameter value or Custom node code must change, not be read (use material.set_material_parameter or material.update_custom_expression).', 'Any other property of a node must change, such as the Texture or SamplerType of a texture parameter (use inspect.set_property with objectPath "<material path>.<material name>:<nodeId>").'],
-        examples: [ex('Inspect one node in detail', { materialPath: M, nodeId: SAMPLE, expressionIndex: 0 }, DONE)] }),
-    r('remove_material_node', 'material', 'Remove a node from a material graph.', schema({ materialPath: MAT, nodeId: str('Node ID to remove.'), nodeIds: arr('Node IDs to remove in one batch, in place of nodeId.') }, ['materialPath'], ['nodeId', 'nodeIds']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['An unused or wrong node must leave a material or function graph, taking its wires with it.', 'Several stray nodes must go in one call (nodeIds).'],
-        whenNotToUse: ['Only the wire to a node must be cleared while the node stays (use material.disconnect_nodes).', 'Unused nodes must be found first (use material.get_material_info with info=subgraph and orphansOnly=true).'],
-        examples: [ex('Remove a node from the graph', { materialPath: M, nodeId: SAMPLE }, DONE)] }),
-    r('set_node_position', 'material', 'Move an existing material graph node to new coordinates, preserving its connections.', schema({ materialPath: MAT, assetPath: str('Material asset path (accepted in place of materialPath).'), nodeId: str('Node ID to move.'), x: num('New X coordinate (posX is the fallback spelling).'), y: num('New Y coordinate (posY is the fallback spelling).'), posX: num('New X coordinate (fallback spelling).'), posY: num('New Y coordinate (fallback spelling).') }, ['nodeId'], ['materialPath', 'assetPath']), MOVE_OUT, WRITE, WRITE_POLICY, LOW, { topics: ['move material node'],
-        whenToUse: ['Overlapping nodes reported by a node add (overlappingNodes) must be spread out without losing wires.', 'A cluttered graph must be tidied by moving an existing node to new x and y.'],
-        whenNotToUse: ['A new node needs a position (pass x and y when adding it with material.add_material_node).', 'Wires must change (use material.connect_nodes or material.disconnect_nodes).'],
-        examples: [ex('Space a stacked parameter node out', { materialPath: M, nodeId: SAMPLE, x: -400, y: 260 }, { success: true, nodeId: SAMPLE, posX: -400, posY: 260 })] }),
-    r('build_material_graph', 'material', 'Build a material graph in one call: add nodes, wire them to each other and to the material output, and set material properties, with $id references between steps.', schema({ materialPath: MAT, operations: OPERATIONS }, ['materialPath', 'operations']), BATCH_OUT, WRITE, WRITE_POLICY, LOW, { whenToUse: ['Many nodes, wires and material properties must be built at once, with the material compiled and saved only at the end.', 'New nodes must be wired to each other in the same call by id ($id) without waiting for node ids.'],
-        whenNotToUse: ['Only one wire is needed (use material.connect_nodes).', 'Nodes must be deleted or unwired; batches do not run those (use material.delete_node or material.disconnect_nodes).'],
-        topics: ['batch material edit', 'build material graph', 'wire many material nodes', 'material graph batch'],
-        examples: [ex('Emissive vertical gradient from two colors', { materialPath: M, operations: [
-                    { edit: 'add_texture_coordinate', id: 'uv' },
-                    { edit: 'add_vector_parameter', id: 'top', parameterName: 'TopColor', defaultValue: { r: 0.01, g: 0.02, b: 0.08, a: 1 } },
-                    { edit: 'add_vector_parameter', id: 'horizon', parameterName: 'HorizonColor', defaultValue: { r: 0.9, g: 0.2, b: 0.6, a: 1 } },
-                    { edit: 'add_material_node', id: 'lerp', nodeType: 'Lerp' },
-                    { edit: 'connect_nodes', from: '$top', to: '$lerp.A' },
-                    { edit: 'connect_nodes', from: '$horizon', to: '$lerp.B' },
-                    { edit: 'connect_nodes', from: '$uv.G', to: '$lerp.Alpha' },
-                    { edit: 'connect_nodes', from: '$lerp', to: 'Main.EmissiveColor' },
-                ] }, { success: true, succeeded: 8, nodeIds: { uv: 'MaterialExpressionTextureCoordinate_0', top: 'MaterialExpressionVectorParameter_0', horizon: 'MaterialExpressionVectorParameter_1', lerp: 'MaterialExpressionLinearInterpolate_0' }, compiled: true, saved: true })] })
-];
-//# sourceMappingURL=material-graph.js.map

package/dist/tools/catalog/capabilities/records/manage-asset/material-nodes.d.ts

@@ -1,3 +0,0 @@
-import type { RecordSpec } from './builder.js';
-export declare const MATERIAL_NODES_RECORDS: readonly RecordSpec[];
-//# sourceMappingURL=material-nodes.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-asset/material-nodes.js

@@ -1,77 +0,0 @@
-import { arrObj, bool, ex, LOW, num, r, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const MAT = str('Material /Game asset path.');
-const TEX = str('Texture /Game asset path.');
-const PARAM = str('Parameter name.');
-const X = num('Node X position (preferred spelling; posX is the fallback).');
-const Y = num('Node Y position (preferred spelling; posY is the fallback).');
-const OK = schema({
-    success: bool('Operation succeeded.'),
-    nodeId: str('Created node ID.'),
-    details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Node details.' },
-    posX: num('X coordinate the node was placed at.'),
-    posY: num('Y coordinate the node was placed at.'),
-    estimatedWidth: num('Approximate node width; an estimate from the node name, not a measurement.'),
-    estimatedHeight: num('Approximate node height, from connector count plus an allowance for a parameter node\'s inline default-value widget. Offset the next node by at least this much to avoid overlap.'),
-    overlappingNodes: { type: 'array', items: { type: 'string' }, description: 'Names of existing expressions whose estimated bounds intersect this one. Absent when placement is clear.' },
-    placementWarning: str('Human-readable overlap warning, present only when overlappingNodes is non-empty.'),
-}, ['success']);
-const M = '/Game/Materials/M_Base';
-const node = (expression) => ({ success: true, nodeId: `MaterialExpression${expression}_0` });
-export const MATERIAL_NODES_RECORDS = [
-    r('add_texture_sample', 'material', 'Add a texture sample node to a material graph.', schema({ materialPath: MAT, texturePath: TEX, parameterName: str('Makes the node a TextureSampleParameter2D with this parameter name, overridable per instance.'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A texture must be sampled in the graph; pass parameterName to make it a texture parameter that instances can override.'],
-        whenNotToUse: ['An instance only needs a different texture (use material.set_material_parameter with parameterKind=texture).', 'The texture asset itself must be made, adjusted or configured (use texture.create_texture, texture.adjust_texture or texture.configure_texture).'],
-        examples: [ex('Sample a rock texture', { materialPath: M, texturePath: '/Game/Textures/T_Rock', x: -400, y: 0 }, node('TextureSample'))] }),
-    r('add_texture_coordinate', 'material', 'Add a texture coordinate node to a material graph.', schema({ materialPath: MAT, coordinateIndex: num('UV channel index (default 0).'), uTiling: num('U tiling factor (default 1).'), vTiling: num('V tiling factor (default 1).'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A texture must repeat more or less often across a surface, or read a UV channel other than 0.'],
-        whenNotToUse: ['The UV node exists and only needs wiring (use material.connect_nodes).'],
-        examples: [ex('Tile UV channel 0 four times', { materialPath: M, coordinateIndex: 0, uTiling: 4, vTiling: 4, x: -600, y: 0 }, node('TextureCoordinate'))] }),
-    r('add_scalar_parameter', 'material', 'Add a scalar parameter node to a material graph.', schema({ materialPath: MAT, parameterName: PARAM, defaultValue: num('Default scalar value.'), group: str('Parameter group.'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath', 'parameterName']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A float value must be tweakable per material instance, such as roughness, opacity or a speed.'],
-        whenNotToUse: ['An existing scalar parameter value must change (use material.set_material_parameter with parameterKind=scalar).'],
-        examples: [ex('Expose a roughness scalar', { materialPath: M, parameterName: 'Roughness', defaultValue: 0.5, group: 'Surface', x: -400, y: 200 }, node('ScalarParameter'))] }),
-    r('add_vector_parameter', 'material', 'Add a vector parameter node to a material graph.', schema({ materialPath: MAT, parameterName: PARAM, defaultValue: { description: 'Default RGBA value.' }, group: str('Parameter group.'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath', 'parameterName']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A color or vector value must be tweakable per instance, such as a tint or an emissive color.'],
-        whenNotToUse: ['An existing vector parameter value must change (use material.set_material_parameter with parameterKind=vector).'],
-        examples: [ex('Expose a tint colour', { materialPath: M, parameterName: 'BaseTint', defaultValue: [1, 1, 1, 1], x: -400, y: 300 }, node('VectorParameter'))] }),
-    r('add_static_switch_parameter', 'material', 'Add a static switch parameter node to a material graph.', schema({ materialPath: MAT, parameterName: PARAM, defaultValue: bool('Default switch value (default false).'), group: str('Parameter group.'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath', 'parameterName']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A compile-time on/off toggle must pick between two graph branches for each instance.'],
-        whenNotToUse: ['The value of an existing switch must change on an instance (use material.set_material_parameter with parameterKind=static_switch).'],
-        examples: [ex('Add a detail-map toggle', { materialPath: M, parameterName: 'UseDetailMap', defaultValue: false, x: -400, y: 400 }, node('StaticSwitchParameter'))] }),
-    r('add_math_node', 'material', 'Add a math operation node to a material graph.', schema({ materialPath: MAT, operation: str('Math operation (Add, Multiply, etc.).'), constA: num('Value used while input A is unwired (Add, Subtract, Multiply, Divide, Lerp).'), constB: num('Value used while input B is unwired (Add, Subtract, Multiply, Divide, Lerp).'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath', 'operation']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['Values must be combined or reshaped: Add, Subtract, Multiply, Divide, Lerp, Clamp, Power, Frac, OneMinus or Append.'],
-        whenNotToUse: ['A math node already exists and only needs new wires (use material.connect_nodes).'],
-        examples: [ex('Halve a value with a multiply', { materialPath: M, operation: 'Multiply', constA: 1, constB: 0.5, x: -200, y: 0 }, node('Multiply'))] }),
-    r('add_world_position', 'material', 'Add a world position node to a material graph.', schema({ materialPath: MAT, posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['The world position of each pixel is needed, for world-aligned textures or height-based blending.'],
-        whenNotToUse: ['The world position node exists and only needs wiring (use material.connect_nodes).'],
-        examples: [ex('Drive shading from world position', { materialPath: M, x: -800, y: 0 }, node('WorldPosition'))] }),
-    r('add_vertex_normal', 'material', 'Add a vertex normal node to a material graph.', schema({ materialPath: MAT, posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['The world-space vertex normal is needed, for example for slope-based blending.'],
-        whenNotToUse: ['A normal map should shade the surface: wire a texture sample into Normal (use material.connect_nodes).'],
-        examples: [ex('Read the world-space vertex normal', { materialPath: M, x: -800, y: 200 }, node('VertexNormalWS'))] }),
-    r('add_pixel_depth', 'material', 'Add a pixel depth node to a material graph.', schema({ materialPath: MAT, posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['Distance from the camera per pixel is needed, for depth fades or distance-based blending.'],
-        whenNotToUse: ['A pixel depth node exists and only needs wiring (use material.connect_nodes).'],
-        examples: [ex('Fade by pixel depth', { materialPath: M, x: -800, y: 400 }, node('PixelDepth'))] }),
-    r('add_fresnel', 'material', 'Add a fresnel node to a material graph.', schema({ materialPath: MAT, posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A rim light, edge glow or view-angle fade is needed.'],
-        whenNotToUse: ['The Fresnel node already exists and only needs wiring (use material.connect_nodes).'],
-        examples: [ex('Add a rim-light fresnel', { materialPath: M, x: -600, y: 600 }, node('Fresnel'))] }),
-    r('add_reflection_vector', 'material', 'Add a reflection vector node to a material graph.', schema({ materialPath: MAT, posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A reflection direction is needed, for example to sample a cubemap for fake reflections.'],
-        whenNotToUse: ['The reflection vector node exists and only needs wiring (use material.connect_nodes).'],
-        examples: [ex('Sample a cubemap by reflection vector', { materialPath: M, x: -800, y: 600 }, node('ReflectionVectorWS'))] }),
-    r('add_panner', 'material', 'Add a panner node to a material graph.', schema({ materialPath: MAT, speedX: num('Pan speed along U.'), speedY: num('Pan speed along V.'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['UVs must scroll over time, as with flowing water or a conveyor belt.'],
-        whenNotToUse: ['The panner exists and only its wiring or position changes (use material.connect_nodes or material.set_node_position).'],
-        examples: [ex('Scroll UVs horizontally', { materialPath: M, speedX: 0.1, speedY: 0, x: -600, y: 200 }, node('Panner'))] }),
-    r('add_rotator', 'material', 'Add a rotator node to a material graph.', schema({ materialPath: MAT, speed: num('Rotation speed.'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['UVs must rotate over time, as with spinning dials or radial effects.'],
-        whenNotToUse: ['The rotator exists and only needs wiring (use material.connect_nodes).'],
-        examples: [ex('Rotate UVs slowly', { materialPath: M, speed: 0.25, x: -600, y: 300 }, node('Rotator'))] }),
-    r('add_noise', 'material', 'Add a noise node to a material graph.', schema({ materialPath: MAT, scale: num('Noise scale.'), levels: num('Number of noise octaves (levels) combined.'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A surface needs procedural variation such as dirt, clouds or breakup, with a scale and a number of octaves (levels).'],
-        whenNotToUse: ['A noise texture asset is wanted instead of a per-pixel node (use texture.create_texture with kind=noise).'],
-        examples: [ex('Add three-octave noise', { materialPath: M, scale: 4, levels: 3, x: -600, y: 400 }, node('Noise'))] }),
-    r('add_voronoi', 'material', 'Add a voronoi noise node to a material graph.', schema({ materialPath: MAT, scale: num('Voronoi scale.'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A cell, crack or cobble-like pattern is needed from a Voronoi noise function; scale is its only setting.'],
-        whenNotToUse: ['The Voronoi node exists and only needs wiring (use material.connect_nodes).'],
-        examples: [ex('Add a voronoi cell pattern', { materialPath: M, scale: 8, x: -600, y: 500 }, { success: true })] }),
-    r('add_if', 'material', 'Add a conditional If node to a material graph.', schema({ materialPath: MAT, posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A value must switch by comparing two numbers: A greater than, equal to or less than B.'],
-        whenNotToUse: ['A per-instance toggle is wanted (add a static switch parameter, then use material.set_material_parameter with parameterKind=static_switch).'],
-        examples: [ex('Branch between two inputs', { materialPath: M, x: -200, y: 200 }, node('If'))] }),
-    r('add_switch', 'material', 'Add a switch node to a material graph.', schema({ materialPath: MAT, posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A compile-time two-way branch is needed with no named parameter, chosen by a bool input or the node default.'],
-        whenNotToUse: ['The choice must change per instance (use a static switch parameter, set with material.set_material_parameter and parameterKind=static_switch).'],
-        examples: [ex('Select between graph branches', { materialPath: M, x: -200, y: 300 }, node('Switch'))] }),
-    r('add_custom_expression', 'material', 'Add a custom HLSL expression node to a material graph.', schema({ materialPath: MAT, code: str('HLSL code.'), outputType: str('Output type: Float1 (default), Float2, Float3, Float4 or MaterialAttributes.'), description: str('Node title shown in the material editor (the Custom node Description).'), inputs: arrObj('Input definitions, each {name}; wire one with connect_nodes targetPin set to that name.'), additionalOutputs: arrObj('Extra output pins after the return value, each {name, type}: type Float1 (default), Float2, Float3, Float4 or MaterialAttributes. Assign each by name in the HLSL (Emis = ...;) and wire it as "$node.Name".'), posX: num('Node X position.'), posY: num('Node Y position.'), x: X, y: Y }, ['materialPath', 'code']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A calculation the standard nodes cannot express is needed as HLSL, with named inputs and optional extra outputs.'],
-        whenNotToUse: ['The code or inputs of an existing Custom node must change (use material.update_custom_expression).'],
-        examples: [ex('Add a scalar HLSL expression', { materialPath: M, code: 'return saturate(A * 2.0f);', outputType: 'CMOT_Float1', x: -200, y: 400 }, node('Custom'))] })
-];
-//# sourceMappingURL=material-nodes.js.map

package/dist/tools/catalog/capabilities/records/manage-asset/material-params.d.ts

@@ -1,3 +0,0 @@
-import type { RecordSpec } from './builder.js';
-export declare const MATERIAL_PARAMS_RECORDS: readonly RecordSpec[];
-//# sourceMappingURL=material-params.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-asset/material-params.js

@@ -1,88 +0,0 @@
-import { arr, arrObj, BLEND_MODE, bool, ex, LOW, MATERIAL_DOMAIN, num, READ, READ_POLICY, r, SHADING_MODEL, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const MAT = str('Material /Game asset path.');
-const MATFN = str('Material function /Game asset path.');
-const MINST = str('Material instance /Game asset path.');
-const MAT_ALIAS = str('Material asset path (accepted in place of assetPath).');
-const SAVE = bool('Save the asset afterwards. Defaults to true; pass false to keep the change in memory only.');
-const INFO_FILTERS = {
-    filter: str('Which sections to return: parameters, expressions, connections, or all (default).'),
-    nodeId: str('Only report connections touching this node.'),
-    nodeIds: arr('Only report connections touching these nodes.'),
-};
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const COMPILE_OK = schema({
-    success: bool('Operation succeeded.'),
-    assetPath: str('Compiled asset path.'),
-    assetType: str('Material or MaterialFunction.'),
-    compiled: bool('False when the material does not compile; compileErrors says why.'),
-    compileErrors: arr('Compile errors from the material translator and, once it has finished, the shader compile (where a Custom node\'s HLSL fails); empty when it compiles.'),
-    saved: bool('Whether the asset was saved.'),
-}, ['success']);
-const MATERIAL_INFO_OK = schema({
-    success: bool('Operation succeeded.'),
-    assetType: str('Asset type: Material, MaterialFunction or MaterialInstance.'),
-    parent: str('MaterialInstance: the material or instance it overrides.'),
-    baseMaterial: str('MaterialInstance: the material at the root of its parent chain, which owns the node graph.'),
-    parameterOverrides: arrObj('MaterialInstance: each overridden parameter (name, type scalar/vector/texture, value).'),
-    nodeCount: num('Number of expression nodes in the graph.'),
-    domain: str('Material domain, e.g. Surface, PostProcess, UI.'),
-    blendMode: str('Blend mode, e.g. Opaque, Masked, Translucent.'),
-    twoSided: bool('Whether the material renders two-sided.'),
-    description: str('Material function description.'),
-    exposeToLibrary: bool('Whether a material function is exposed to the library.'),
-    parameters: arrObj('Material parameters of every kind (name, type, nodeId). A texture parameter also carries texture (its default texture path, empty while none is set) and samplerType (Color, Normal, Masks, ...); a runtime virtual texture parameter carries its virtual texture under texture.'),
-    inputs: arrObj('Material function inputs (name, type, nodeId).'),
-}, ['success']);
-const M = '/Game/Materials/M_Base';
-const MI = '/Game/Materials/MI_Base_Rusty';
-const MF = '/Game/Materials/Functions/MF_HeightBlend';
-const DONE = { success: true };
-export const MATERIAL_PARAMS_RECORDS = [
-    r('set_blend_mode', 'material', 'Set the blend mode of a material.', schema({ assetPath: MAT, blendMode: BLEND_MODE, save: SAVE }, ['assetPath', 'blendMode']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A material must become translucent, cut out (Masked) or additive instead of Opaque.'],
-        whenNotToUse: ['The target is a material instance; only a base material can be edited here (find it with material.get_material_info).', 'A new material is being created with the blend mode already known (use material.create_material with blendMode).'],
-        examples: [ex('Switch a material to masked blending', { assetPath: M, blendMode: 'Masked' }, DONE)] }),
-    r('set_shading_model', 'material', 'Set the shading model of a material.', schema({ assetPath: MAT, shadingModel: SHADING_MODEL, save: SAVE }, ['assetPath', 'shadingModel']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A surface needs a different shading model, such as DefaultLit, Unlit, Subsurface, ClearCoat or Hair.'],
-        whenNotToUse: ['The target is a material instance; only a base material can be edited here (find it with material.get_material_info).', 'A new material is being created with the shading model already known (use material.create_material with shadingModel).'],
-        examples: [ex('Use the default lit shading model', { assetPath: M, shadingModel: 'DefaultLit' }, DONE)] }),
-    r('set_material_domain', 'material', 'Set the material domain of a material.', schema({ assetPath: MAT, materialDomain: MATERIAL_DOMAIN, save: SAVE }, ['assetPath', 'materialDomain']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A material must change domain, for example between Surface, DeferredDecal, PostProcess and UI.'],
-        whenNotToUse: ['The target is a material instance; only a base material can be edited here (find it with material.get_material_info).', 'A new material is being created with the domain already known (use material.create_material with materialDomain).'],
-        examples: [ex('Keep a material in the surface domain', { assetPath: M, materialDomain: 'Surface' }, DONE)] }),
-    r('compile_material', 'material', 'Compile a material and report its compile errors.', schema({ assetPath: MAT, materialPath: MAT_ALIAS, save: SAVE }, [], ['assetPath', 'materialPath']), COMPILE_OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['The compile errors of an edited graph must be read; a material that fails to compile renders as the default material.', 'Graph edits left the asset unsaved, so it must be compiled and saved.'],
-        whenNotToUse: ['A property or parameter was just set (material.set_material_property and material.set_material_parameter already recompile).', 'Domain, blend mode or node counts are wanted rather than compile errors (use material.get_material_info).'],
-        examples: [ex('Compile after editing the graph', { assetPath: M }, DONE)] }),
-    r('get_material_info', 'material', 'Read a material or material function (domain, blend mode, parameters, node count), or a material instance (its parent and parameter overrides).', schema({ assetPath: MAT, materialPath: MAT_ALIAS, ...INFO_FILTERS }, [], ['assetPath', 'materialPath']), MATERIAL_INFO_OK, READ, READ_POLICY, LOW, { whenToUse: ['An existing material must be understood before editing: node ids, parameter names, wiring, domain and blend mode, or the parent and overrides of an instance.'],
-        whenNotToUse: ['Shading model, sampler counts or the instances of a parent are wanted (use asset.query_asset lookup=material_stats or asset.list kind=material_instances).'],
-        examples: [ex('Read a material\'s configuration', { assetPath: M }, { success: true, assetType: 'Material', nodeCount: 4, domain: 'Surface', blendMode: 'Opaque', twoSided: false })] }),
-    r('set_two_sided', 'material', 'Set the two-sided flag on a material.', schema({ assetPath: MAT, value: bool('Two-sided value: true renders both faces, false only the front.'), save: SAVE }, ['assetPath', 'value']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['Both faces of a mesh must render, as with leaves, cloth or thin sheets.'],
-        whenNotToUse: ['The target is a material instance; only a base material can be edited here (find it with material.get_material_info).'],
-        examples: [ex('Render a material from both sides', { assetPath: M, value: true }, DONE)] }),
-    r('add_function_input', 'material', 'Add a function input to a material function.', schema({ assetPath: MATFN, inputName: str('Input name.'), inputType: str('Input type.'), x: num('Node X position (preferred spelling; posX is the fallback).'), y: num('Node Y position (preferred spelling; posY is the fallback).') }, ['assetPath', 'inputName']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A material function needs an input pin (scalar, vector, Texture2D, TextureCube, Bool or MaterialAttributes) that callers wire into.'],
-        whenNotToUse: ['The asset is a base material; only material functions take input or output pins (a material result goes to Main with material.connect_nodes).', 'The function does not exist yet (use material.create_material with kind=function).'],
-        examples: [ex('Add a scalar height input', { assetPath: MF, inputName: 'Height', inputType: 'Scalar', x: -400, y: 0 }, DONE)] }),
-    r('add_function_output', 'material', 'Add a function output to a material function.', schema({ assetPath: MATFN, inputName: str('Output name.'), inputType: str('Output type.'), x: num('Node X position (preferred spelling; posX is the fallback).'), y: num('Node Y position (preferred spelling; posY is the fallback).') }, ['assetPath', 'inputName']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A material function needs a named result pin so a graph can wire its result out.'],
-        whenNotToUse: ['The asset is a base material; only material functions take input or output pins (a material result goes to Main with material.connect_nodes).', 'The function does not exist yet (use material.create_material with kind=function).'],
-        examples: [ex('Add the blended result output', { assetPath: MF, inputName: 'Result', inputType: 'Scalar', x: 400, y: 0 }, DONE)] }),
-    r('use_material_function', 'material', 'Insert a material function reference into a material graph.', schema({ materialPath: MAT, functionPath: str('Material function /Game path.'), x: num('Node X position (preferred spelling; posX is the fallback).'), y: num('Node Y position (preferred spelling; posY is the fallback).') }, ['materialPath', 'functionPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A reusable material function must be called from a material or another function as a single node.'],
-        whenNotToUse: ['The function does not exist yet (use material.create_material with kind=function).', 'The function needs another input or output pin (use material.add_function_io).'],
-        examples: [ex('Reference a blend function from a material', { materialPath: M, functionPath: MF, x: -200, y: 500 }, DONE)] }),
-    r('get_material_function_info', 'material', 'Retrieve information about a material function.', schema({ assetPath: MATFN, materialPath: MAT_ALIAS, ...INFO_FILTERS }, [], ['assetPath', 'materialPath']), OK, READ, READ_POLICY, LOW, { whenToUse: ['A material function must be understood before calling or editing it: its inputs, outputs, description and library exposure.'],
-        whenNotToUse: ['The materials that call the function must be found (use asset.inspect_asset with lookup=dependencies and referencers=true).'],
-        examples: [ex('Read a function\'s inputs and outputs', { assetPath: MF }, DONE)] }),
-    r('set_scalar_parameter_value', 'material', 'Set a scalar parameter value on a material instance.', schema({ assetPath: MINST, parameterName: str('Parameter name.'), value: num('Scalar value.'), save: SAVE }, ['assetPath', 'parameterName', 'value']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A float parameter such as roughness, opacity or a speed must change on an instance or as a base material default.'],
-        whenNotToUse: ['The parameter is not on the base material yet (add it there with asset.edit_material_instance edit=add_parameter or material.add_material_node).'],
-        examples: [ex('Override roughness on an instance', { assetPath: MI, parameterName: 'Roughness', value: 0.8 }, DONE)] }),
-    r('set_vector_parameter_value', 'material', 'Set a vector parameter value on a material instance.', schema({ assetPath: MINST, parameterName: str('Parameter name.'), value: { description: 'Vector value.' }, save: SAVE }, ['assetPath', 'parameterName', 'value']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A color or vector parameter such as a tint must change; value takes an rgba object or an array of at least three numbers.'],
-        whenNotToUse: ['The parameter is not on the base material yet (add it there with asset.edit_material_instance edit=add_parameter or material.add_material_node).'],
-        examples: [ex('Tint an instance rust-orange', { assetPath: MI, parameterName: 'BaseTint', value: [0.55, 0.27, 0.1, 1] }, DONE)] }),
-    r('set_texture_parameter_value', 'material', 'Set a texture parameter value on a material instance.', schema({ assetPath: MINST, parameterName: str('Parameter name.'), texturePath: str('Texture /Game path.'), save: SAVE }, ['assetPath', 'parameterName', 'texturePath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A texture parameter must point at a different texture asset (texturePath).'],
-        whenNotToUse: ['The parameter is not on the base material yet (add it there with asset.edit_material_instance edit=add_parameter or material.add_material_node).', 'The texture asset itself needs other compression or LOD settings (use texture.configure_texture).'],
-        examples: [ex('Swap the base colour texture', { assetPath: MI, parameterName: 'BaseColor', texturePath: '/Game/Textures/T_Rust' }, DONE)] }),
-    r('add_landscape_layer', 'material', 'Create the landscape layer info asset (the weight layer a landscape material paints) for a layer name, beside the material or in path.', schema({ materialPath: str('Landscape material the layer belongs to; the layer info asset is created in its folder unless path is given.'), layerName: str('Layer name.'), path: str('Folder for the layer info asset, e.g. /Game/Landscape/Layers (overrides the material folder).'), hardness: num('Layer hardness, 0-1 (default 0.5).'), physicalMaterialPath: str('Physical material the layer applies, e.g. /Game/Physics/PM_Grass.'), noWeightBlend: bool('Exclude the layer from weight blending (default false).'), save: SAVE }, ['materialPath', 'layerName']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A landscape weight layer needs its layer info asset, with hardness, physical material and weight-blend option, so it can be painted.'],
-        whenNotToUse: ['The material needs a layer blend node that lists the layers (use material.configure_layer_blend).', 'The landscape must be painted with the layer (use build_environment.edit_landscape with edit=paint_landscape_layer).'],
-        examples: [ex('Add a grass weight-blended layer', { materialPath: '/Game/Materials/Landscape/M_Landscape', layerName: 'Grass' }, DONE)] }),
-    r('configure_layer_blend', 'material', 'Configure layer blend settings on a landscape material.', schema({ materialPath: MAT, layers: arrObj('Layer blend definitions.'), blendType: str('Blend type.'), x: num('Node X position of the layer blend node.'), y: num('Node Y position of the layer blend node.'), save: SAVE }, ['materialPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A landscape material needs a Landscape Layer Blend node listing its paint layers, each with a weight, height or alpha blend.', 'All named layers must be added to one blend node in one call (layers takes [{name, blendType}] or plain names).'],
-        whenNotToUse: ['Layer info assets for the layers must be created (use material.add_material_node with nodeKind=landscape_layer).', 'A finished material must be assigned to a landscape (use build_environment.sculpt with sculptOp=material).'],
-        examples: [ex('Weight-blend the landscape layers', { materialPath: '/Game/Materials/Landscape/M_Landscape', blendType: 'LB_WeightBlend' }, DONE)] })
-];
-//# sourceMappingURL=material-params.js.map

package/dist/tools/catalog/capabilities/records/manage-asset/struct-records.d.ts

@@ -1,3 +0,0 @@
-import type { RecordSpec } from './builder.js';
-export declare const STRUCT_RECORDS: readonly RecordSpec[];
-//# sourceMappingURL=struct-records.d.ts.map