Skip to content
Project referenceDevelopmentEngine ccf7d03f
Authored
  • Owned Game/Plugin build transactions, content freezing and final platform publication.

Owned Game/Plugin build transactions, content freezing and final platform publication.

Read the linked task or ownership explanation before using the exact API below.

BuildPipeline owns Game/Plugin orchestration, generation checks, streaming Content Packs, Support Pack validation, staging and installation. It borrows authoring services and does not reference Editor. Platform layout comes from IGameBuildTarget; content compiler and managed deployment provider are separate registered capabilities.

Prepare the selected Support Pack asynchronously before starting BuildGameAsync on the authoring owner’s thread. Keep the returned lease until consumption finishes. A normal await does not return to that thread automatically. BuildGameAsync rejects a missing Pack rather than synchronously waiting for a provider while taking asset snapshots. A distribution host can consume preinstalled immutable Packs without a source provisioner.

Copy the profile, freeze its output location and capture Assets/Plugins/Settings revisions and Serialization generation. Freeze content and logical script closure, validate the trimmed script API, then compile against the actual deployment’s engine assemblies. Generate static registration, invoke the selected managed compiler, validate result identity/file membership and delegate final layout to the platform packager. Failure, cancellation or changed generation preserves the previous committed product.

SdkScriptCompilationEnvironment captures references and final symbols from the explicitly selected SDK in the authoring source context. Its process-owned SDK inputs live under Library/Scripting/SdkInputs; tasks drain before release. It does not expose MSBuild/Roslyn to the neutral compiler, guess reference-pack versions, rewrite global.json or mutate SDK/NuGet caches.

BuildTargetId is portable/open; actual support comes from registered immutable GameBuildTargetBinding values. Missing saved targets retain their ID and display Missing instead of being rewritten to the current OS. Settings.Build.inno supplies versioned authoring defaults; absent defaults derive from project name, host target and the first sorted imported deployable scene, excluding ~ sample directories. Only Settings Apply persists them. Each export dialog copies a fresh one-off request.

Game/Plugin identity comes from current Project ID, not a second Build identifier. persistentDataPath is a portable relative Local Application Data subdirectory; empty selects Application ID. Segments allow lowercase letters, digits, dot, underscore and hyphen but reject dot/dot-dot and absolute paths. Only Project settings enter Player runtime, not Editor or Build defaults.

Reject outputs inside Assets, Plugins or Library, corrupt artifacts, unavailable Support Packs, missing runtime assemblies, escaping platform output paths and authoring-only startup scenes before commit. Content packing freezes exact keys, lengths and hashes with one deterministic index.

AtomicDirectory.Install coordinates two directory moves; callers own target read/write exclusion. It is not a gap-free file replacement. Installation failure attempts to restore the old directory. Post-commit backup-cleanup failure reports installed and residual paths while retaining the complete new output. Do not interpret that failure as an absent installation.

Pack catalogs validate the complete immutable target/fingerprint directory and its platform requirements under a reading lease. Current-index updates do not redirect an active consumer. Read Support Packs, Player publication and distribution composition.

Supply existing live dependencies. This example checks the host contract; it does not initialize a complete product or certify a physical device.

using System;
using System.Threading;
using System.Threading.Tasks;
using Inno.Build;
static ValueTask<PlayerSupportPackLease> PrepareAsync(
BuildPipeline pipeline,
BuildProfile profile,
CancellationToken cancellationToken
) => pipeline.EnsurePlayerSupportPackAsync(
profile.target, profile.managedDeployment, cancellationToken);
static ValueTask<BuildResult> StartOnAuthoringThread(
BuildPipeline pipeline,
BuildProfile profile,
string outputDirectory,
IProgress<BuildProgress>? progress,
CancellationToken cancellationToken
) {
return pipeline.BuildGameAsync(new GameBuildRequest
{
profile = profile,
outputDirectory = outputDirectory
}, progress, cancellationToken);
}

The source project defines the selected host declarations. Script projection and platform execution require their separate evidence.

Browse types and members.

Project: Inno.Build
Source: build/pipeline/Inno.Build/Inno.Build.csproj

Type API Description
BuildDiagnostic engine Describes one stable machine-readable build problem or informational event.
BuildDiagnosticSeverity engine Identifies the severity of one structured build diagnostic.
BuildPipeline engine Orchestrates deterministic Plugin and game builds over isolated staging and atomic commits.
BuildProfile engine Defines reusable product and startup settings for deterministic game builds.
BuildProfileStore engine Persists one project’s current game build profile through the engine serialization contract.
BuildProgress engine Reports monotonic progress for one asynchronous build operation.
BuildResult engine Reports the immutable outcome, diagnostics, and optional durable output of one build.
BuildSettings engine Defines project-owned defaults copied into each temporary game or Plugin export request.
BuildSettingsStore engine Persists project-owned export defaults independently from temporary export requests.
BuildTargetId engine Identifies one stable platform and architecture combination supported by the game build pipeline.
GameBuildContentContext engine Supplies isolated staging and profile data for target-specific offline artifact generation.
GameBuildPackageContext engine Supplies an isolated staging layout to a replaceable platform packager.
GameBuildRequest engine Requests one game build from the current validated authoring generation.
GameBuildTargetBinding engine Binds independent packaging and content implementations for one publication target.
IGameBuildTarget engine Defines the replaceable platform packaging boundary for one game build target.
IGameContentCompiler engine Compiles source-free runtime content independently of application packaging.
IPlayerSupportPackProvisioner engine Prepares current Player Support Pack inputs without coupling game builds to an SDK or platform toolchain.
IPlayerSupportPackValidator engine Validates platform-owned runtime or link inputs without coupling the pack catalog to target names.
PlatformTargetDescriptor engine Declares immutable product target facts independently of the machine executing build tools.
PlayerSupportPackCatalog engine Resolves and validates installed Player Support Packs without loading authoring services.
PlayerSupportPackLease engine Keeps verified Player compilation and linker inputs alive until their consumer finishes.
PluginBuildRequest engine Requests one deterministic project-to-Plugin package without a companion authoring asset.
SdkScriptCompilationEnvironment engine Evaluates the authoring project’s selected SDK and maps its framework contract into scripting inputs.