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

package/dist/tools/catalog/capabilities/records/build-environment/procedural.data.js

@@ -1,72 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'procedural';
-export const PROCEDURAL_RECORDS = [
-    buildRecord({
-        id: 'build_environment.create_procedural_terrain', action: 'create_procedural_terrain', family: F,
-        summary: 'Create a procedural terrain mesh actor.',
-        whenToUse: ['A procedural terrain mesh must be generated.'],
-        whenNotToUse: ['A heightmap-based landscape should be used instead.'],
-        inputProps: { name: { ...P.name, description: 'Label of the terrain actor (default ProceduralTerrain; actorName is accepted too).' },
-            actorName: P.actorName, location: P.location,
-            sizeX: P.sizeX, sizeY: P.sizeY, heightScale: P.heightScale, subdivisions: P.subdivisions,
-            spacing: { ...P.spacing, description: 'World units per sizeX and sizeY unit: the terrain spans sizeX*spacing by sizeY*spacing (default 100).' },
-            rotation: P.rotation, material: { ...P.material, description: 'Material for the terrain; a path that does not load fails the call.' } },
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        dispatchAction: 'create_procedural_terrain',
-        exampleInput: { action: 'create_procedural_terrain', name: 'PTerrain_1', sizeX: 1000, sizeY: 1000 },
-    }),
-    buildRecord({
-        id: 'build_environment.bake_lightmap', action: 'bake_lightmap', family: F,
-        summary: 'Bake lightmaps for the current level.',
-        whenToUse: ['Lightmaps must be baked for static lighting.'],
-        whenNotToUse: ['Dynamic lighting is sufficient.'],
-        inputProps: { quality: P.quality },
-        effect: 'write', behavior: { longRunning: true, idempotency: 'idempotent' },
-        latency: 'long-running', resources: 'high',
-        dispatchAction: 'bake_lightmap',
-        exampleInput: { action: 'bake_lightmap', quality: 'Preview' },
-    }),
-    buildRecord({
-        id: 'build_environment.export_snapshot', action: 'export_snapshot', topics: ['save environment snapshot'], family: F,
-        summary: 'Export an environment snapshot to a file.',
-        whenToUse: ['An environment state must be exported for later restoration.'],
-        whenNotToUse: ['The level should be saved directly.'],
-        inputProps: { path: P.path, filename: P.filename,
-            directionalLightActorPath: P.directionalLightActorPath, skyLightActorPath: P.skyLightActorPath },
-        outputProps: { directionalLightActorPath: P.directionalLightActorPath, skyLightActorPath: P.skyLightActorPath },
-        outputRequired: [],
-        effect: 'read', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'export_snapshot', path: '/Game/Snapshots', filename: 'env.json',
-            directionalLightActorPath: '/Game/Maps/Main.Main:PersistentLevel.DirectionalLight_0' },
-        exampleOutput: { success: true, message: 'Snapshot exported',
-            directionalLightActorPath: '/Game/Maps/Main.Main:PersistentLevel.DirectionalLight_0',
-            skyLightActorPath: '/Game/Maps/Main.Main:PersistentLevel.SkyLight_0' },
-    }),
-    buildRecord({
-        id: 'build_environment.import_snapshot', action: 'import_snapshot', topics: ['load an environment snapshot'], family: F,
-        summary: 'Import an environment snapshot from a file.',
-        whenToUse: ['A previously exported environment snapshot must be restored.'],
-        whenNotToUse: ['The environment should be rebuilt from scratch.'],
-        inputProps: { path: P.path, filename: P.filename },
-        outputProps: { directionalLightActorPath: P.directionalLightActorPath, skyLightActorPath: P.skyLightActorPath },
-        outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'import_snapshot', path: '/Game/Snapshots', filename: 'env.json' },
-        exampleOutput: { success: true, message: 'Snapshot imported',
-            directionalLightActorPath: '/Game/Maps/Main.Main:PersistentLevel.DirectionalLight_0',
-            skyLightActorPath: '/Game/Maps/Main.Main:PersistentLevel.SkyLight_0' },
-    }),
-    buildRecord({
-        id: 'build_environment.delete', action: 'delete', topics: ['delete water, ocean, lake, river or landscape'], family: F,
-        summary: 'Delete environment actors by name or path.',
-        whenToUse: ['Environment actors must be permanently removed.'],
-        whenNotToUse: ['Actors should be hidden rather than deleted.'],
-        inputProps: { names: P.names, name: P.name, actorPath: P.actorPath,
-            actorName: P.actorName, targetActor: P.targetActor },
-        effect: 'destructive', behavior: { safeToRetry: false },
-        latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'delete', names: ['Landscape_1'] },
-    }),
-];
-//# sourceMappingURL=procedural.data.js.map

package/dist/tools/catalog/capabilities/records/build-environment/properties.d.ts

@@ -1,166 +0,0 @@
-import type { JsonObject } from '../../model.js';
-export declare const P: {
-    name: JsonObject;
-    landscapeName: JsonObject;
-    landscapePath: JsonObject;
-    landscapeActorPath: JsonObject;
-    materialPath: JsonObject;
-    material: JsonObject;
-    meshPath: JsonObject;
-    staticMesh: JsonObject;
-    foliageType: JsonObject;
-    foliageTypePath: JsonObject;
-    actorName: JsonObject;
-    actorPath: JsonObject;
-    targetActor: JsonObject;
-    location: JsonObject;
-    rotation: JsonObject;
-    position: JsonObject;
-    radius: JsonObject;
-    strength: JsonObject;
-    falloff: JsonObject;
-    tool: JsonObject;
-    layerName: JsonObject;
-    operation: JsonObject;
-    heightData: JsonObject;
-    minX: JsonObject;
-    minY: JsonObject;
-    maxX: JsonObject;
-    maxY: JsonObject;
-    updateNormals: JsonObject;
-    skipFlush: JsonObject;
-    sizeX: JsonObject;
-    sizeY: JsonObject;
-    sectionSize: JsonObject;
-    sectionsPerComponent: JsonObject;
-    componentCount: JsonObject;
-    quadsPerSection: JsonObject;
-    seed: JsonObject;
-    heightScale: JsonObject;
-    subdivisions: JsonObject;
-    density: JsonObject;
-    minScale: JsonObject;
-    maxScale: JsonObject;
-    cullDistance: JsonObject;
-    alignToNormal: JsonObject;
-    randomYaw: JsonObject;
-    area: {
-        type: string;
-        description: string;
-        properties: {
-            min: JsonObject;
-            max: JsonObject;
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    snapToSurface: JsonObject;
-    locations: JsonObject;
-    transforms: JsonObject;
-    removeAll: JsonObject;
-    quality: JsonObject;
-    filename: JsonObject;
-    path: JsonObject;
-    numLODs: JsonObject;
-    assetPath: JsonObject;
-    assetPaths: JsonObject;
-    assets: JsonObject;
-    names: JsonObject;
-    time: JsonObject;
-    hour: JsonObject;
-    intensity: JsonObject;
-    color: JsonObject;
-    properties: JsonObject;
-    recapture: JsonObject;
-    size: JsonObject;
-    skyLightIntensity: JsonObject;
-    lightType: JsonObject;
-    lightClass: JsonObject;
-    cubemapPath: JsonObject;
-    directionalLightActorPath: JsonObject;
-    skyLightActorPath: JsonObject;
-    curvePath: JsonObject;
-    particleSystemPath: JsonObject;
-    waterBodyName: JsonObject;
-    waveHeight: JsonObject;
-    waveLength: JsonObject;
-    amplitude: JsonObject;
-    steepness: JsonObject;
-    speed: JsonObject;
-    direction: JsonObject;
-    azimuth: JsonObject;
-    elevation: JsonObject;
-    pointIndex: JsonObject;
-    pointRotation: JsonObject;
-    pointScale: JsonObject;
-    pointType: JsonObject;
-    index: JsonObject;
-    arriveTangent: JsonObject;
-    leaveTangent: JsonObject;
-    splineType: JsonObject;
-    bClosedLoop: JsonObject;
-    forwardAxis: JsonObject;
-    componentName: JsonObject;
-    blueprintPath: JsonObject;
-    spacing: JsonObject;
-    width: JsonObject;
-    closedLoop: JsonObject;
-    alignToSpline: JsonObject;
-    randomizeRotation: JsonObject;
-    randomizeScale: JsonObject;
-    randomOffsetRange: JsonObject;
-    settings: JsonObject;
-    ppSettings: JsonObject;
-    actorSettings: JsonObject;
-    region: JsonObject;
-    bounds: JsonObject;
-    foliageTypes: JsonObject;
-    points: JsonObject;
-    tileSize: JsonObject;
-    volumeName: JsonObject;
-    physicalMaterialPath: JsonObject;
-    layerInfoPath: JsonObject;
-    renderTargetPath: JsonObject;
-    lutPath: JsonObject;
-    captureOffset: JsonObject;
-    aperture: JsonObject;
-    distance: JsonObject;
-    blendWeight: JsonObject;
-    screenPercentage: JsonObject;
-    amount: JsonObject;
-    threshold: JsonObject;
-    minBrightness: JsonObject;
-    maxBrightness: JsonObject;
-    enabled: JsonObject;
-    method: JsonObject;
-    materialIndex: JsonObject;
-    compensationValue: JsonObject;
-    infiniteUnbound: JsonObject;
-    collisionEnabled: JsonObject;
-    save: JsonObject;
-    propertyValueNumber: JsonObject;
-    outputPath: JsonObject;
-    count: JsonObject;
-    hardness: JsonObject;
-    noWeightBlend: JsonObject;
-    channels: JsonObject;
-    rotationRange: JsonObject;
-    raiseTerrain: JsonObject;
-    lowerTerrain: JsonObject;
-    castShadows: JsonObject;
-    shadowBias: JsonObject;
-    shadowSlopeBias: JsonObject;
-    shadowResolutionScale: JsonObject;
-    shadowQuality: JsonObject;
-    shadowDistance: JsonObject;
-    contactShadows: JsonObject;
-    rayTracedShadows: JsonObject;
-    virtualShadowMaps: JsonObject;
-    indirectLightingIntensity: JsonObject;
-    bounces: JsonObject;
-    viewDistance: JsonObject;
-    useRandomOffset: JsonObject;
-    initialPoints: JsonObject;
-};
-export type PropertyMap = JsonObject;
-//# sourceMappingURL=properties.d.ts.map

package/dist/tools/catalog/capabilities/records/build-environment/properties.js

@@ -1,212 +0,0 @@
-import { str, num, bool } from '../shared/schema-props.js';
-const int = (d) => ({ type: 'integer', description: d });
-const arr = (d, item) => ({ type: 'array', items: item, description: d });
-const vec3 = (d) => ({
-    type: 'object', description: d,
-    properties: { x: num('X'), y: num('Y'), z: num('Z') },
-    additionalProperties: false,
-});
-const rot = (d) => ({
-    type: 'object', description: d,
-    properties: { pitch: num('Pitch'), yaw: num('Yaw'), roll: num('Roll') },
-    additionalProperties: false,
-});
-export const P = {
-    name: str('Name for the new actor, asset, or volume.'),
-    landscapeName: str('Target landscape actor name.'),
-    landscapePath: str('Canonical /Game landscape asset path.'),
-    landscapeActorPath: str('Landscape actor path in the level.'),
-    materialPath: str('Canonical /Game material asset path.'),
-    material: str('Canonical /Game material asset path.'),
-    meshPath: str('Canonical /Game static mesh asset path.'),
-    staticMesh: str('Canonical /Game static mesh asset path.'),
-    foliageType: str('Foliage type name or path.'),
-    foliageTypePath: str('Canonical /Game foliage type asset path.'),
-    actorName: str('Actor name in the current level.'),
-    actorPath: str('Actor path in the level.'),
-    targetActor: str('Target actor name for the operation.'),
-    location: vec3('World-space location {x, y, z}.'),
-    rotation: rot('Rotation {pitch, yaw, roll}.'),
-    position: vec3('Position {x, y, z}.'),
-    radius: num('Brush radius in world units.'),
-    strength: num('Brush strength (0-1).'),
-    falloff: num('Brush falloff (0-1).'),
-    tool: str('Sculpt tool: Raise (default), Lower or Flatten (towards the location\'s z). Any other name is refused.'),
-    layerName: str('Landscape layer name.'),
-    operation: str('Heightmap operation: set, add, subtract, smooth.'),
-    heightData: arr('Heightmap values.', num('Height value.')),
-    minX: num('Region min X.'), minY: num('Region min Y.'),
-    maxX: num('Region max X.'), maxY: num('Region max Y.'),
-    updateNormals: bool('Recompute normals after modification.'),
-    skipFlush: bool('Skip flushing rendering after the operation.'),
-    sizeX: num('Landscape size in quads (X).'),
-    sizeY: num('Landscape size in quads (Y).'),
-    sectionSize: num('Quads per section (same as quadsPerSection): 7, 15, 31, 63 (default), 127 or 255.'),
-    sectionsPerComponent: num('Sections per component side: 1 (default) or 2, for 2x2 sections per component.'),
-    componentCount: vec3('Component count {x, y}.'),
-    quadsPerSection: num('Quads per section: 7, 15, 31, 63 (default), 127 or 255. A component spans sectionsPerComponent sections.'),
-    seed: int('Random seed for procedural generation.'),
-    heightScale: num('Height scale multiplier.'),
-    subdivisions: int('Mesh subdivision count.'),
-    density: num('Foliage density.'),
-    minScale: num('Minimum foliage scale.'),
-    maxScale: num('Maximum foliage scale.'),
-    cullDistance: num('Cull distance in world units.'),
-    alignToNormal: bool('Align instance to surface normal.'),
-    randomYaw: bool('Apply random yaw rotation.'),
-    area: {
-        type: 'object',
-        description: 'A box min..max. Painting: instances spread evenly over min..max in X and Y, and each drops onto the ground found between 500 above max.z and 1000 below min.z. Removing: only the instances whose location lies inside min..max on all three axes (a pit or a path), every type unless foliageType names one.',
-        properties: { min: vec3('Minimum corner.'), max: vec3('Maximum corner.') },
-        required: ['min', 'max'],
-        additionalProperties: false,
-    },
-    snapToSurface: bool('Drop each point onto the first static surface below it (default true). Points with no surface below - over a pit or off the level - are skipped and reported as skippedNoSurface.'),
-    locations: arr('Instance locations.', vec3('Location.')),
-    transforms: arr('Instance transforms.', {
-        type: 'object', description: 'Transform with location, rotation, scale.',
-        properties: { location: vec3('Location.'), rotation: rot('Rotation.'), scale: vec3('Scale.') },
-        additionalProperties: false,
-    }),
-    removeAll: bool('Remove all foliage instances.'),
-    quality: str('Lightmap bake quality (Preview, Medium, High, Production).'),
-    filename: str('File name for snapshot export/import.'),
-    path: str('Canonical /Game asset or directory path.'),
-    numLODs: int('Number of LODs to generate.'),
-    assetPath: str('Canonical /Game static mesh path (one asset; assetPaths takes several).'),
-    assetPaths: arr('Asset paths for LOD generation.', str('Asset path.')),
-    assets: arr('Asset paths for LOD generation.', str('Asset path.')),
-    names: arr('Actor names to delete.', str('Actor name.')),
-    time: num('Time of day in hours (0-24).'),
-    hour: num('Hour of day (0-23).'),
-    intensity: num('Light intensity.'),
-    color: {
-        type: 'object', description: 'Light color {r, g, b, a} in 0-1 (a missing channel reads 0, alpha 1).',
-        properties: { r: num('Red.'), g: num('Green.'), b: num('Blue.'), a: num('Alpha.') }, additionalProperties: false,
-    },
-    properties: {
-        type: 'object', description: 'Light component values for point, spot, rect and directional lights: intensity, color, attenuationRadius, castShadows and the like; a properties.color wins over color.',
-        additionalProperties: true, 'x-unreal-reflection-boundary': true,
-    },
-    recapture: bool('Recapture the sky light after the change.'),
-    size: vec3('Box size in world units {x, y, z} (default 1000 on each axis).'),
-    skyLightIntensity: num('Sky light intensity.'),
-    lightType: str('Light type string.'),
-    lightClass: str('Light class string.'),
-    cubemapPath: str('Canonical /Game cubemap asset path.'),
-    directionalLightActorPath: str('Directional light actor path. As input, selects the light to snapshot; the first directional light in the level is used when omitted. As output, the resolved actor path.'),
-    skyLightActorPath: str('Sky light actor path. As input, selects the light to snapshot; the first sky light in the level is used when omitted. As output, the resolved actor path.'),
-    curvePath: str('Canonical /Game curve asset path.'),
-    particleSystemPath: str('Canonical /Game particle system asset path.'),
-    waterBodyName: str('Water body actor name.'),
-    waveHeight: num('Wave height.'), waveLength: num('Wave length.'),
-    amplitude: num('Wave amplitude.'), steepness: num('Wave steepness.'),
-    speed: num('Animation or wave speed.'),
-    direction: rot('Direction rotation.'),
-    azimuth: num('Sun azimuth in degrees: the yaw of the light.'), elevation: num('Sun elevation: degrees above the horizon (90 = overhead, negative = below it).'),
-    pointIndex: int('Spline point index.'),
-    pointRotation: rot('Spline point rotation.'), pointScale: vec3('Spline point scale.'),
-    pointType: str('Spline point type (Linear, Curve, Constant, etc.).'),
-    index: int('Insert the point before this index; appended when omitted or out of range.'),
-    arriveTangent: vec3('Arrive tangent.'), leaveTangent: vec3('Leave tangent.'),
-    splineType: str('Spline point type.'),
-    bClosedLoop: bool('Whether the spline is a closed loop.'),
-    forwardAxis: str('Spline mesh forward axis (X, Y, Z).'),
-    componentName: str('Component name.'),
-    blueprintPath: str('Canonical /Game blueprint path.'),
-    spacing: num('Mesh spacing along the spline.'),
-    width: num('Spline width.'),
-    closedLoop: bool('Close the spline into a loop, joining the last point back to the first.'),
-    alignToSpline: bool('Align meshes to spline direction.'),
-    randomizeRotation: bool('Randomize mesh rotation.'),
-    randomizeScale: bool('Randomize mesh scale.'),
-    randomOffsetRange: num('Random offset range.'),
-    settings: {
-        type: 'object', description: 'Action-specific settings key-value pairs.',
-        additionalProperties: true, 'x-unreal-reflection-boundary': true,
-    },
-    ppSettings: {
-        type: 'object',
-        description: 'FPostProcessSettings fields by engine name, e.g. {"ColorSaturation": {"x": 1.1, "y": 1.1, "z": 1.1, "w": 1}, '
-            + '"VignetteIntensity": 0.3}; each field\'s bOverride_ flag is set for you. A key that is not a field is listed under '
-            + 'unsupportedSettings, and when no key is one the call fails naming the closest fields.',
-        additionalProperties: true, 'x-unreal-reflection-boundary': true,
-    },
-    actorSettings: {
-        type: 'object',
-        description: 'Property values for the actor or its component, keyed by the Unreal property name (case-insensitive): '
-            + '{"Intensity": 2, "LightColor": {"R": 0.6, "G": 0.7, "B": 1}} for a light, {"FogDensity": 0.02} for fog. '
-            + 'A key neither declares is named in configurationErrors and fails the call.',
-        additionalProperties: true, 'x-unreal-reflection-boundary': true,
-    },
-    region: {
-        type: 'object', description: 'Rectangular region {minX, minY, maxX, maxY}.',
-        properties: { minX: num('Min X.'), minY: num('Min Y.'), maxX: num('Max X.'), maxY: num('Max Y.') },
-        additionalProperties: false,
-    },
-    bounds: {
-        type: 'object', description: 'Procedural foliage bounds {location, size}.',
-        properties: { location: vec3('Bounds location.'), size: vec3('Bounds size.') },
-        additionalProperties: false,
-    },
-    foliageTypes: arr('Foliage type specs.', {
-        type: 'object', description: 'Foliage type with mesh and density.',
-        properties: { meshPath: str('Mesh path.'), density: num('Density.') },
-        additionalProperties: false,
-    }),
-    points: arr('Spline points.', {
-        type: 'object', description: 'Spline point with position and tangent.',
-        properties: {
-            position: vec3('Position.'), arriveTangent: vec3('Arrive tangent.'),
-            leaveTangent: vec3('Leave tangent.'), rotation: rot('Rotation.'), scale: vec3('Scale.'),
-        },
-        additionalProperties: false,
-    }),
-    tileSize: num('Procedural foliage tile size.'),
-    volumeName: str('Volume actor name.'),
-    physicalMaterialPath: str('Canonical /Game physical material path.'),
-    layerInfoPath: str('Canonical /Game landscape layer info asset path.'),
-    renderTargetPath: str('Render target path string.'),
-    lutPath: str('Canonical /Game LUT texture path.'),
-    captureOffset: vec3('Capture offset.'),
-    aperture: num('Camera aperture (f-stop).'),
-    distance: num('Focus distance.'),
-    blendWeight: num('Blend weight (0-1).'),
-    screenPercentage: num('Screen percentage (0-100).'),
-    amount: num('Effect amount.'), threshold: num('Effect threshold.'),
-    minBrightness: num('Minimum brightness.'), maxBrightness: num('Maximum brightness.'),
-    enabled: bool('Whether the feature is enabled.'),
-    method: str('Method string.'), materialIndex: int('Material index.'),
-    compensationValue: num('Exposure compensation value.'),
-    infiniteUnbound: bool('Whether the volume is infinite and unbound.'),
-    collisionEnabled: bool('Whether collision is enabled.'),
-    save: bool('Whether to save after the operation.'),
-    propertyValueNumber: num('Numeric property value.'),
-    outputPath: str('Filesystem path the heightmap is written to.'),
-    count: int('How many instances to place over the brush disc (location + radius) or the area; overrides density.'),
-    hardness: num('Landscape layer hardness (0-1).'),
-    noWeightBlend: bool('Disable weight blending for the landscape layer.'),
-    channels: arr('Lighting channel indices (0, 1, or 2).', int('Lighting channel index.')),
-    rotationRange: num('Random rotation range in degrees.'),
-    raiseTerrain: bool('Whether the spline raises the terrain up to it (default true).'),
-    lowerTerrain: bool('Whether the spline lowers the terrain down to it (default true).'),
-    castShadows: bool('Whether the light (actorName) casts shadows.'),
-    shadowBias: num('Shadow depth bias of the light (actorName).'),
-    shadowSlopeBias: num('Shadow slope bias of the light (actorName).'),
-    shadowResolutionScale: num('Shadow resolution scale of the light (actorName).'),
-    shadowQuality: str('Shadow quality scalability level (sg.ShadowQuality): Low, Medium, High, Epic or Cinematic.'),
-    shadowDistance: num('Shadow draw distance scale (r.Shadow.DistanceScale).'),
-    contactShadows: bool('Whether contact shadows render (r.ContactShadows).'),
-    rayTracedShadows: bool('Whether ray-traced shadows are enabled (r.RayTracing.Shadows). Distinct from virtualShadowMaps.'),
-    virtualShadowMaps: bool('Whether virtual shadow maps are enabled. Distinct from rayTracedShadows.'),
-    indirectLightingIntensity: num('Indirect lighting intensity, written with its override on the level\'s post-process volume (spawned when missing).'),
-    bounces: int('Lightmass indirect lighting bounces (World Settings), used by baked lighting.'),
-    viewDistance: num('Volumetric fog view distance in world units.'),
-    useRandomOffset: bool('Apply a random offset to scattered meshes.'),
-    initialPoints: arr('Initial spline points (alias of points).', {
-        type: 'object', description: 'Spline point with a world location.',
-        properties: { location: vec3('Point location.') },
-        additionalProperties: false,
-    }),
-};
-//# sourceMappingURL=properties.js.map

package/dist/tools/catalog/capabilities/records/build-environment/render-postprocess.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const RENDER_POSTPROCESS_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=render-postprocess.data.d.ts.map

package/dist/tools/catalog/capabilities/records/build-environment/render-postprocess.data.js

@@ -1,40 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'render';
-const WU = ['Post-process, exposure, or screen effect settings must be configured.'];
-const ID = 'build_environment.';
-const R = (action, summary, inputProps, required = []) => buildRecord({
-    id: ID + action, action, family: F, summary, whenToUse: WU,
-    whenNotToUse: ['Default post-process settings are sufficient.'],
-    inputProps: { actorName: P.actorName, blendWeight: P.blendWeight, infiniteUnbound: P.infiniteUnbound, ...inputProps }, required,
-    effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low',
-    exampleInput: { action },
-});
-export const RENDER_POSTPROCESS_RECORDS = [
-    R('configure_ssr_settings', 'Configure screen-space reflections.', { settings: P.ppSettings }),
-    R('configure_lumen_reflection_settings', 'Configure Lumen reflection settings.', { settings: P.ppSettings }),
-    R('configure_pp_blend', 'Configure a post-process volume\'s blend weight, unbound flag and whether it is enabled.', { enabled: { ...P.enabled, description: 'Whether the volume is enabled.' } }),
-    R('set_pp_white_balance', 'Set post-process white balance.', { settings: P.ppSettings }),
-    R('set_pp_color_grading', 'Set post-process color grading.', { settings: P.ppSettings }),
-    R('set_pp_lut', 'Set post-process LUT texture.', { lutPath: P.lutPath }),
-    R('configure_tonemapper', 'Configure tonemapper settings.', { settings: P.ppSettings }),
-    R('set_tonemapper_type', 'Set tonemapper type.', { method: P.method }),
-    R('configure_bloom', 'Configure bloom settings.', { settings: P.ppSettings, amount: { ...P.amount, description: 'Bloom intensity.' }, threshold: { ...P.threshold, description: 'Bloom threshold (-1 = everything blooms).' } }),
-    R('set_bloom_intensity', 'Set bloom intensity.', { amount: P.amount }),
-    R('set_bloom_threshold', 'Set bloom threshold.', { threshold: P.threshold }),
-    R('configure_lens_flare', 'Configure lens flare settings.', { settings: P.ppSettings, enabled: { ...P.enabled, description: 'false zeroes the lens flare intensity.' } }),
-    R('configure_dof', 'Configure depth of field.', { settings: P.ppSettings }),
-    R('set_dof_method', 'Set depth of field method.', { method: P.method }),
-    R('set_focal_distance', 'Set focal distance for DOF.', { distance: P.distance }),
-    R('set_aperture', 'Set camera aperture (f-stop).', { aperture: P.aperture }),
-    R('configure_bokeh', 'Configure bokeh settings.', { settings: P.ppSettings }),
-    R('configure_motion_blur', 'Configure motion blur settings.', { settings: P.ppSettings }),
-    R('set_motion_blur_amount', 'Set motion blur amount.', { amount: P.amount }),
-    R('set_motion_blur_max', 'Set motion blur maximum.', { amount: P.amount }),
-    R('configure_exposure', 'Configure exposure settings.', {
-        settings: P.ppSettings, compensationValue: P.compensationValue, minBrightness: P.minBrightness, maxBrightness: P.maxBrightness,
-        method: { ...P.method, description: 'Auto-exposure method: Manual, Histogram or Basic.' },
-    }),
-    R('set_exposure_method', 'Set exposure method.', { method: P.method }),
-];
-//# sourceMappingURL=render-postprocess.data.js.map

package/dist/tools/catalog/capabilities/records/build-environment/render-raytrace.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const RENDER_RAYTRACE_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=render-raytrace.data.d.ts.map

package/dist/tools/catalog/capabilities/records/build-environment/render-raytrace.data.js

@@ -1,39 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'render';
-const WU = ['Render or lighting quality settings must be configured.'];
-const ID = 'build_environment.';
-const CHANNEL_ENABLED = { ...P.enabled, description: 'Turn the channels on (default true) or off.' };
-const REFLECTION = {
-    name: { ...P.name, description: 'Label of the new capture actor; an actor with it already is reported, not duplicated.' },
-    actorName: P.actorName, location: P.location, rotation: P.rotation,
-};
-const CAPTURE_SETTINGS = { ...P.settings, description: 'Reflection capture component properties by name, e.g. {"Brightness": 1.5}.' };
-const R = (action, summary, inputProps, required = [], effect = 'write', exampleInput = { action }, requiredOneOf) => buildRecord({
-    id: ID + action, action, family: F, summary, whenToUse: WU,
-    whenNotToUse: ['Default rendering settings are sufficient.'],
-    inputProps, required, ...(requiredOneOf === undefined ? {} : { requiredOneOf }),
-    effect, behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-    exampleInput,
-});
-export const RENDER_RAYTRACE_RECORDS = [
-    R('configure_ray_traced_shadows', 'Configure ray-traced shadow settings.', { settings: P.settings, enabled: P.enabled }),
-    R('configure_ray_traced_gi', 'Configure ray-traced global illumination.', { settings: P.settings, enabled: P.enabled }),
-    R('configure_ray_traced_reflections', 'Configure ray-traced reflections.', { settings: P.settings, enabled: P.enabled }),
-    R('configure_ray_traced_ao', 'Configure ray-traced ambient occlusion.', { settings: P.settings, enabled: P.enabled, intensity: { ...P.intensity, description: 'Ray-traced ambient occlusion intensity (r.RayTracing.AmbientOcclusion.Intensity).' } }),
-    R('configure_path_tracing', 'Configure path tracing settings.', { settings: P.settings, enabled: P.enabled }),
-    R('set_light_channel', 'Turn lighting channels on or off for a light actor.', { actorName: P.actorName, channel: { type: 'integer', description: 'Light channel index.' }, channels: P.channels, enabled: CHANNEL_ENABLED }),
-    R('set_actor_light_channel', 'Turn lighting channels on or off for a target actor\'s primitives.', { actorName: P.actorName, targetActor: P.targetActor, channel: { type: 'integer', description: 'Light channel index.' }, channels: P.channels, enabled: CHANNEL_ENABLED }),
-    R('configure_lightmass_settings', 'Configure Lightmass global settings.', { settings: P.settings }),
-    R('build_lighting_quality', 'Build lighting at a specific quality.', { quality: P.quality }),
-    R('configure_indirect_lighting_cache', 'Configure indirect lighting cache on an actor\'s primitive components.', { actorName: P.actorName, settings: P.settings, enabled: { ...P.enabled, description: 'Indirect lighting cache on (point sampled) or off for each primitive.' } }, ['actorName'], 'write', { action: 'configure_indirect_lighting_cache', actorName: 'StaticMeshActor_1', enabled: false }),
-    R('create_sphere_reflection_capture', 'Create a sphere reflection capture actor.', { ...REFLECTION, settings: CAPTURE_SETTINGS }, [], 'write', { action: 'create_sphere_reflection_capture', name: 'SphereRC_1' }, ['name', 'actorName']),
-    R('create_box_reflection_capture', 'Create a box reflection capture actor.', { ...REFLECTION, settings: CAPTURE_SETTINGS }, [], 'write', { action: 'create_box_reflection_capture', name: 'BoxRC_1' }, ['name', 'actorName']),
-    R('configure_reflection_capture_resolution', 'Set reflection capture resolution (project-wide CVar; marks the named capture, or every capture, for recapture).', { actorName: P.actorName, resolution: { type: 'integer', description: 'Capture resolution.' } }),
-    R('configure_capture_resolution', 'Set scene capture resolution.', { actorName: P.actorName, resolution: { type: 'integer', description: 'Capture resolution.' } }),
-    R('configure_capture_offset', 'Set scene capture offset.', { actorName: P.actorName, captureOffset: P.captureOffset }),
-    R('recapture_scene', 'Recapture a reflection or scene capture.', { actorName: P.actorName }),
-    R('create_planar_reflection', 'Create a planar reflection actor.', REFLECTION, [], 'write', { action: 'create_planar_reflection', name: 'PlanarRC_1' }, ['name', 'actorName']),
-    R('configure_planar_reflection', 'Configure planar reflection settings.', { actorName: P.actorName, settings: P.settings }),
-];
-//# sourceMappingURL=render-raytrace.data.js.map

package/dist/tools/catalog/capabilities/records/build-environment/render-screen.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const RENDER_SCREEN_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=render-screen.data.d.ts.map

package/dist/tools/catalog/capabilities/records/build-environment/render-screen.data.js

@@ -1,36 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'render';
-const WU = ['Exposure, ambient occlusion, screen, or capture settings must be configured.'];
-const ID = 'build_environment.';
-const R = (action, summary, inputProps, required = []) => buildRecord({
-    id: ID + action, action, family: F, summary, whenToUse: WU,
-    whenNotToUse: ['Default settings are sufficient.'],
-    inputProps: { actorName: P.actorName, ...inputProps }, required,
-    effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low',
-    exampleInput: { action },
-});
-const BLEND = { blendWeight: P.blendWeight, infiniteUnbound: P.infiniteUnbound };
-export const RENDER_SCREEN_RECORDS = [
-    R('set_exposure_compensation', 'Set exposure compensation value.', { compensationValue: P.compensationValue, ...BLEND }),
-    R('set_exposure_min_max', 'Set exposure min and max brightness; a bound left out keeps its value.', { minBrightness: P.minBrightness, maxBrightness: P.maxBrightness, ...BLEND }),
-    R('configure_ssao', 'Configure screen-space ambient occlusion.', { settings: P.ppSettings, amount: { ...P.amount, description: 'Ambient occlusion intensity; written after settings.' }, ...BLEND }),
-    R('configure_gtao', 'Configure ground-truth ambient occlusion.', { settings: P.ppSettings, ...BLEND }),
-    R('configure_vignette', 'Configure vignette settings.', { amount: P.amount, ...BLEND }),
-    R('configure_chromatic_aberration', 'Configure chromatic aberration.', { settings: P.ppSettings, amount: { ...P.amount, description: 'Scene fringe intensity; written after settings.' }, ...BLEND }),
-    R('configure_grain', 'Configure film grain settings.', { settings: P.ppSettings, amount: { ...P.amount, description: 'Film grain intensity; written after settings.' }, ...BLEND }),
-    buildRecord({
-        id: `${ID}configure_screen_percentage`, action: 'configure_screen_percentage', family: F,
-        summary: 'Set screen percentage for rendering (the r.ScreenPercentage console variable; no volume involved).',
-        whenToUse: WU, whenNotToUse: ['Default settings are sufficient.'],
-        inputProps: { screenPercentage: P.screenPercentage },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low',
-        exampleInput: { action: 'configure_screen_percentage', screenPercentage: 75 },
-    }),
-    R('create_scene_capture_2d', 'Create a 2D scene capture actor.', { name: P.name, location: P.location, rotation: P.rotation }),
-    R('create_scene_capture_cube', 'Create a cube scene capture actor.', { name: P.name, location: P.location, rotation: P.rotation }),
-    R('configure_capture_source', 'Configure scene capture source.', { captureSource: { type: 'string', description: 'What the capture renders: FinalColorLDR, SceneColorHDR, SceneDepth, BaseColor, Normal or an SCS_ value. Required.' } }, ['captureSource']),
-    R('assign_render_target', 'Assign a render target to a scene capture.', { actorName: P.actorName, renderTargetPath: P.renderTargetPath }),
-    R('capture_scene', 'Trigger a scene capture on an actor.', { actorName: P.actorName }),
-];
-//# sourceMappingURL=render-screen.data.js.map

package/dist/tools/catalog/capabilities/records/build-environment/spline.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const SPLINE_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=spline.data.d.ts.map