public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length < 2)
{
return;
}
if (!int.TryParse(args[0], out var id) ||
!float.TryParse(args[1], out var temperature))
{
return;
}
var gridId = new GridId(id);
var mapMan = IoCManager.Resolve <IMapManager>();
if (temperature < Atmospherics.TCMB)
{
shell.WriteLine("Invalid temperature.");
return;
}
if (!gridId.IsValid() || !mapMan.TryGetGrid(gridId, out var gridComp))
{
shell.WriteLine("Invalid grid ID.");
return;
}
var atmosphereSystem = EntitySystem.Get <AtmosphereSystem>();
var tiles = 0;
foreach (var tile in atmosphereSystem.GetAllTileMixtures(gridId, true))
{
tiles++;
tile.Temperature = temperature;
}
shell.WriteLine($"Changed the temperature of {tiles} tiles.");
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length != 1)
{
shell.WriteError($"Invalid arguments.\n{Help}");
return;
}
if (shell.Player is not IPlayerSession player)
{
shell.WriteError("You must be a player to run this command.");
return;
}
if (player.AttachedEntity is not {
} attached)
{
shell.WriteError("You must have an entity to run this command.");
return;
}
var prototypeManager = IoCManager.Resolve <IPrototypeManager>();
if (!prototypeManager.TryIndex(args[0], out EntityListPrototype? prototype))
{
shell.WriteError($"No {nameof(EntityListPrototype)} found with id {args[0]}");
return;
}
var entityManager = IoCManager.Resolve <IEntityManager>();
var i = 0;
foreach (var entity in prototype.Entities(prototypeManager))
{
entityManager.SpawnEntity(entity.ID, entityManager.GetComponent <TransformComponent>(attached).Coordinates);
i++;
}
shell.WriteLine($"Spawned {i} entities.");
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length < 1)
{
return;
}
if (!int.TryParse(args[0], out var intMapId))
{
return;
}
var mapId = new MapId(intMapId);
// no loading null space
if (mapId == MapId.Nullspace)
{
shell.WriteError("You cannot load into map 0.");
return;
}
var mapManager = IoCManager.Resolve <IMapManager>();
if (mapManager.MapExists(mapId))
{
shell.WriteError($"Map {mapId} already exists.");
return;
}
IoCManager.Resolve <IMapLoader>().LoadMap(mapId, args[1]);
if (mapManager.MapExists(mapId))
{
shell.WriteLine($"Map {mapId} has been loaded from {args[1]}.");
}
else
{
shell.WriteError($"Error while loading map from {args[1]}.");
}
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length < 1)
{
shell.WriteLine(Help);
return;
}
if (!int.TryParse(args[0], out var id))
{
shell.WriteLine($"{args[0]} is not a valid integer.");
return;
}
var gridId = new GridId(id);
var mapMan = IoCManager.Resolve <IMapManager>();
if (!gridId.IsValid() || !mapMan.TryGetGrid(gridId, out var gridComp))
{
shell.WriteLine($"{gridId} is not a valid grid id.");
return;
}
if (!_entities.EntityExists(gridComp.GridEntityId))
{
shell.WriteLine("Failed to get grid entity.");
return;
}
if (_entities.HasComponent <IAtmosphereComponent>(gridComp.GridEntityId))
{
shell.WriteLine("Grid already has an atmosphere.");
return;
}
_entities.AddComponent <GridAtmosphereComponent>(gridComp.GridEntityId);
shell.WriteLine($"Added atmosphere to grid {id}.");
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
var prototypeManager = IoCManager.Resolve <IPrototypeManager>();
var mapLoader = IoCManager.Resolve <IMapLoader>();
var entityManager = IoCManager.Resolve <IEntityManager>();
var stationSystem = entityManager.EntitySysManager.GetEntitySystem <StationSystem>();
if (args.Length is not(2 or 4 or 5))
{
shell.WriteError(Loc.GetString("shell-wrong-arguments-number"));
return;
}
if (prototypeManager.TryIndex <GameMapPrototype>(args[0], out var gameMap))
{
if (int.TryParse(args[1], out var mapId))
{
var gameMapEnt = mapLoader.LoadBlueprint(new MapId(mapId), gameMap.MapPath.ToString());
if (gameMapEnt is null)
{
shell.WriteError($"Failed to create the given game map, is the path {gameMap.MapPath} correct?");
return;
}
if (args.Length >= 4 && int.TryParse(args[2], out var x) && int.TryParse(args[3], out var y))
{
var transform = entityManager.GetComponent <TransformComponent>(gameMapEnt.GridEntityId);
transform.WorldPosition = new Vector2(x, y);
}
var stationName = args.Length == 5 ? args[4] : null;
stationSystem.InitialSetupStationGrid(gameMapEnt.GridEntityId, gameMap, stationName);
}
}
else
{
shell.WriteError($"The given map prototype {args[0]} is invalid.");
}
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length < 1)
{
shell.WriteLine("Wrong number of args.");
return;
}
var entId = new EntityUid(int.Parse(args[0]));
if (!IoCManager.Resolve <IEntityManager>().TryGetEntity(entId, out var ent))
{
shell.WriteLine($"Unable to find entity with uid {entId}");
return;
}
if (ent.HasComponent <AiControllerComponent>())
{
shell.WriteLine("Entity already has an AI component.");
return;
}
// TODO: IMover refffaaccctttooorrr
if (ent.HasComponent <IMoverComponent>())
{
ent.RemoveComponent <IMoverComponent>();
}
var comp = ent.AddComponent <UtilityAi>();
var behaviorManager = IoCManager.Resolve <INpcBehaviorManager>();
for (var i = 1; i < args.Length; i++)
{
var bSet = args[i];
behaviorManager.AddBehaviorSet(comp, bSet, false);
}
behaviorManager.RebuildActions(comp);
shell.WriteLine("AI component added.");
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
var player = shell.Player as IPlayerSession;
if (player?.AttachedEntity == null)
{
shell.WriteLine(Loc.GetString("shell-only-players-can-run-this-command"));
return;
}
if (args.Length < 1)
{
shell.WriteLine(Help);
return;
}
if (!EntityUid.TryParse(args[0], out var id))
{
shell.WriteLine(Loc.GetString("shell-invalid-entity-uid", ("uid", args[0])));
return;
}
var entityManager = IoCManager.Resolve <IEntityManager>();
if (!entityManager.TryGetEntity(id, out var entity))
{
shell.WriteLine(Loc.GetString("shell-could-not-find-entity-with-uid", ("uid", id)));
return;
}
if (!entity.TryGetComponent(out IDisposalTubeComponent? tube))
{
shell.WriteLine(Loc.GetString("shell-entity-with-uid-lacks-component",
("uid", id),
("componentName", nameof(IDisposalTubeComponent))));
return;
}
tube.PopupDirections(player.AttachedEntity);
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length < 2)
{
return;
}
if (!int.TryParse(args[0], out var intMapId))
{
return;
}
var mapId = new MapId(intMapId);
// no loading into null space
if (mapId == MapId.Nullspace)
{
shell.WriteError("Cannot load into nullspace.");
return;
}
var mapManager = IoCManager.Resolve <IMapManager>();
if (!mapManager.MapExists(mapId))
{
shell.WriteError("Target map does not exist.");
return;
}
var loadOptions = new MapLoadOptions();
if (args.Length > 2)
{
loadOptions.StoreMapUids = bool.Parse(args[2]);
}
var mapLoader = IoCManager.Resolve <IMapLoader>();
mapLoader.LoadBlueprint(mapId, args[1], loadOptions);
}
public void Execute(IConsoleShell shell, IPlayerSession player, string[] args)
{
bool?enable = null;
if (args.Length > 0)
{
if (args[0] == "on")
{
enable = true;
}
else if (args[0] == "off")
{
enable = false;
}
else if (bool.TryParse(args[0], out var boolean))
{
enable = boolean;
}
else if (int.TryParse(args[0], out var num))
{
if (num == 1)
{
enable = true;
}
else if (num == 0)
{
enable = false;
}
}
}
if (!IoCManager.Resolve <IEntitySystemManager>().TryGetEntitySystem <SignalLinkerSystem>(out var system))
{
return;
}
var ret = system.SignalLinkerKeybind(player.UserId, enable);
shell.SendText(player, ret ? "Enabled" : "Disabled");
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (shell.Player is not IPlayerSession player)
{
shell.WriteLine("shell-server-cannot");
return;
}
if (args.Length != 1)
{
shell.WriteLine(Loc.GetString("shell-wrong-arguments-number"));
return;
}
if (!int.TryParse(args[0], out var targetId))
{
shell.WriteLine(Loc.GetString("shell-argument-must-be-number"));
return;
}
var target = new EntityUid(targetId);
if (!target.IsValid() || !_entities.EntityExists(target))
{
shell.WriteLine(Loc.GetString("shell-invalid-entity-id"));
return;
}
if (!_entities.HasComponent <MindComponent>(target))
{
shell.WriteLine(Loc.GetString("shell-entity-is-not-mob"));
return;
}
var mind = player.ContentData()?.Mind;
DebugTools.AssertNotNull(mind);
mind !.TransferTo(target);
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (shell.Player is not IPlayerSession player)
{
shell.WriteLine(Loc.GetString("shell-cannot-run-command-from-server"));
return;
}
if (player.Status != SessionStatus.InGame || player.AttachedEntity == null)
{
return;
}
var mind = player.ContentData()?.Mind;
// This check also proves mind not-null for at the end when the mob is ghosted.
if (mind?.OwnedComponent?.Owner is not {
Valid : true
} victim)
{
shell.WriteLine("You don't have a mind!");
return;
}
var gameTicker = EntitySystem.Get <GameTicker>();
var suicideSystem = EntitySystem.Get <SuicideSystem>();
if (suicideSystem.Suicide(victim))
{
// Prevent the player from returning to the body.
// Note that mind cannot be null because otherwise victim would be null.
gameTicker.OnGhostAttempt(mind !, false);
return;
}
if (gameTicker.OnGhostAttempt(mind, true))
{
return;
}
shell?.WriteLine("You can't ghost right now.");
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
var wantName = args.Length > 0 ? args[0] : null;
var basePath = Path.GetDirectoryName(UserDataDir.GetUserDataDir()) !;
var dbPath = Path.Combine(basePath, "launcher", "settings.db");
using var con = new SqliteConnection($"Data Source={dbPath};Mode=ReadOnly");
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = "SELECT UserId, UserName, Token FROM Login WHERE Expires > datetime('NOW')";
if (wantName != null)
{
cmd.CommandText += " AND UserName = @userName";
cmd.Parameters.AddWithValue("@userName", wantName);
}
cmd.CommandText += " LIMIT 1;";
using var reader = cmd.ExecuteReader();
if (!reader.Read())
{
shell.WriteLine("Unable to find a matching login");
return;
}
var userId = Guid.Parse(reader.GetString(0));
var userName = reader.GetString(1);
var token = reader.GetString(2);
var cfg = IoCManager.Resolve <IAuthManager>();
cfg.Token = token;
cfg.UserId = new NetUserId(userId);
shell.WriteLine($"Logged into account {userName}");
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
Filter filter;
switch (args.Length)
{
// No arguments, show command help.
case 0:
shell.WriteLine(Help);
return;
// No users, play sound for everyone.
case 1:
// Filter.Broadcast does resolves IPlayerManager, so use this instead.
filter = Filter.Empty().AddAllPlayers(_playerManager);
break;
// One or more users specified.
default:
filter = Filter.Empty();
// Skip the first argument, which is the sound path.
for (var i = 1; i < args.Length; i++)
{
var username = args[i];
if (!_playerManager.TryGetSessionByUsername(username, out var session))
{
shell.WriteError(Loc.GetString("play-global-sound-command-player-not-found", ("username", username)));
continue;
}
filter.AddPlayer(session);
}
break;
}
SoundSystem.Play(filter, args[0], AudioParams.Default);
}
public static bool TryGetSessionByUsernameOrId(IConsoleShell shell,
string usernameOrId, IPlayerSession performer, [NotNullWhen(true)] out IPlayerSession?session)
{
var plyMgr = IoCManager.Resolve <IPlayerManager>();
if (plyMgr.TryGetSessionByUsername(usernameOrId, out session))
{
return(true);
}
if (Guid.TryParse(usernameOrId, out var targetGuid))
{
if (plyMgr.TryGetSessionById(new NetUserId(targetGuid), out session))
{
return(true);
}
shell.SendText(performer, "Unable to find user with that name/id.");
return(false);
}
shell.SendText(performer, "Unable to find user with that name/id.");
return(false);
}
public void Execute(IConsoleShell shell, IPlayerSession player, string[] args)
{
if (args.Length != 2)
{
shell.SendText(player, "Expected exactly 2 arguments.");
return;
}
var mgr = IoCManager.Resolve <IPlayerManager>();
if (mgr.TryGetPlayerData(new NetSessionId(args[0]), out var data))
{
var mind = data.ContentData().Mind;
var refl = IoCManager.Resolve <IReflectionManager>();
var type = refl.LooseGetType(args[1]);
mind.RemoveRole(type);
}
else
{
shell.SendText(player, "Can't find that mind");
}
}
public void Execute(IConsoleShell shell, IPlayerSession?player, string[] args)
{
if (args.Length < 1)
{
return;
}
if (!int.TryParse(args[0], out var id))
{
return;
}
var gridId = new GridId(id);
var mapMan = IoCManager.Resolve <IMapManager>();
if (!gridId.IsValid() || !mapMan.TryGetGrid(gridId, out var gridComp))
{
shell.SendText(player, "Invalid grid ID.");
return;
}
var entMan = IoCManager.Resolve <IEntityManager>();
if (!entMan.TryGetEntity(gridComp.GridEntityId, out var grid))
{
shell.SendText(player, "Failed to get grid entity.");
return;
}
if (grid.HasComponent <GridAtmosphereComponent>())
{
shell.SendText(player, "Grid already has an atmosphere.");
return;
}
grid.AddComponent <GridAtmosphereComponent>();
shell.SendText(player, $"Added atmosphere to grid {id}.");
}
public void Execute(IConsoleShell shell, IPlayerSession?player, string[] args)
{
if (player == null)
{
shell?.SendText(player, "You have no session, you can't ghost.");
return;
}
var mind = player.ContentData()?.Mind;
if (mind == null)
{
shell?.SendText(player, "You have no Mind, you can't ghost.");
return;
}
if (!IoCManager.Resolve <IGameTicker>().OnGhostAttempt(mind, CanReturn))
{
shell?.SendText(player, "You can't ghost right now.");
return;
}
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length != 2)
{
shell.WriteError(Loc.GetString("shell-wrong-arguments-number"));
return;
}
if (!EntityUid.TryParse(args[0], out var entityUid))
{
shell.WriteError(Loc.GetString("shell-entity-uid-must-be-number"));
return;
}
if (!EntityUid.TryParse(args[1], out var storageUid))
{
shell.WriteError(Loc.GetString("shell-entity-uid-must-be-number"));
return;
}
var entityManager = IoCManager.Resolve <IEntityManager>();
if (entityManager.TryGetComponent <BodyPartComponent>(storageUid, out var storage) &&
entityManager.TryGetComponent <MechanismComponent>(entityUid, out var bodyPart))
{
if (storage.TryAddMechanism(bodyPart))
{
shell.WriteLine($@"Added {entityUid} to {storageUid}.");
}
else
{
shell.WriteError($@"Could not add {entityUid} to {storageUid}.");
}
}
else
{
shell.WriteError("Could not insert.");
}
}
public async void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (shell.Player is not IPlayerSession player)
{
shell.WriteError("This does not work from the server console.");
return;
}
Guid notedPlayer;
switch (args.Length)
{
case 1 when Guid.TryParse(args[0], out notedPlayer):
break;
default:
shell.WriteError($"Invalid arguments.\n{Help}");
return;
}
await IoCManager.Resolve <IAdminNotesManager>().OpenEui(player, notedPlayer);
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (!(shell.Player is IPlayerSession))
{
shell.WriteError(Loc.GetString("Only players can use this command"));
return;
}
if (args.Length < 1)
{
return;
}
var colorArg = string.Join(" ", args).Trim();
if (string.IsNullOrEmpty(colorArg))
{
return;
}
var color = Color.TryFromHex(colorArg);
if (!color.HasValue)
{
shell.WriteError(Loc.GetString("Invalid color hex!"));
return;
}
var userId = shell.Player.UserId;
// Save the DB
var dbMan = IoCManager.Resolve <IServerDbManager>();
dbMan.SaveAdminOOCColorAsync(userId, color.Value);
// Update the cached preference
var prefManager = IoCManager.Resolve <IServerPreferencesManager>();
var prefs = prefManager.GetPreferences(userId);
prefs.AdminOOCColor = color.Value;
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length != 2)
{
shell.WriteLine("Wrong number of arguments");
return;
}
var entityUid = EntityUid.Parse(args[0]);
var componentName = args[1];
var compManager = IoCManager.Resolve <IComponentManager>();
var compFactory = IoCManager.Resolve <IComponentFactory>();
var entityManager = IoCManager.Resolve <IEntityManager>();
var entity = entityManager.GetEntity(entityUid);
var component = (Component)compFactory.GetComponent(componentName);
component.Owner = entity;
compManager.AddComponent(entity, component);
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (shell.Player is not IPlayerSession player)
{
shell.WriteError("This command cannot be run from the server.");
return;
}
if (args.Length < 1)
{
return;
}
var message = string.Join(" ", args).Trim();
if (string.IsNullOrEmpty(message))
{
return;
}
IoCManager.Resolve <IChatManager>().SendOOC(player, message);
}
public async void Execute(IConsoleShell shell, string argStr, string[] args)
{
var player = shell.Player as IPlayerSession;
var plyMgr = IoCManager.Resolve <IPlayerManager>();
var dbMan = IoCManager.Resolve <IServerDbManager>();
var target = args[0];
var reason = args[1];
var duration = int.Parse(args[2]);
NetUserId targetUid;
if (plyMgr.TryGetSessionByUsername(target, out var targetSession))
{
targetUid = targetSession.UserId;
}
else if (Guid.TryParse(target, out var targetGuid))
{
targetUid = new NetUserId(targetGuid);
}
else
{
shell.WriteLine("Unable to find user with that name.");
return;
}
DateTimeOffset?expires = null;
if (duration > 0)
{
expires = DateTimeOffset.Now + TimeSpan.FromMinutes(duration);
}
await dbMan.AddServerBanAsync(new ServerBanDef(targetUid, null, DateTimeOffset.Now, expires, reason, player?.UserId));
if (plyMgr.TryGetSessionById(targetUid, out var targetPlayer))
{
targetPlayer.ConnectedClient.Disconnect("You've been banned. Tough shit.");
}
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length < 1)
{
shell.WriteError("Need at least one argument");
return;
}
var playerName = args[0];
var reason = args.Length > 1 ? args[1] : "Ghost kicked by console";
var players = IoCManager.Resolve <IPlayerManager>();
var ghostKick = IoCManager.Resolve <GhostKickManager>();
if (!players.TryGetSessionByUsername(playerName, out var player))
{
shell.WriteError($"Unable to find player: '{playerName}'.");
return;
}
ghostKick.DoDisconnect(player.ConnectedClient, reason);
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length != 1)
{
shell.WriteLine(Help);
return;
}
var id = args[0].ToLower();
var entityManager = IoCManager.Resolve <IEntityManager>();
var query = new PredicateEntityQuery(e => e.Prototype?.ID.ToLower() == id);
var entities = entityManager.GetEntities(query);
var i = 0;
foreach (var entity in entities)
{
entity.Delete();
i++;
}
shell.WriteLine($"Deleted all entities with id {id}. Occurrences: {i}");
}
public void Execute(IConsoleShell shell, IPlayerSession player, string[] args)
{
if (args.Length != 2)
{
shell.SendText(player, "Invalid argument amount. Expected 2 arguments.");
return;
}
var name = args[0];
var levelname = args[1];
LogLevel?level;
if (levelname == "null")
{
level = null;
}
else
{
level = (LogLevel)Enum.Parse(typeof(LogLevel), levelname);
}
Logger.GetSawmill(name).Level = level;
}
public CompletionResult GetCompletion(IConsoleShell shell, string[] args)
{
var levelNames = new string[] {};
var player = shell.Player as IPlayerSession;
if (player?.AttachedEntity != null)
{
var stationUid = EntitySystem.Get <StationSystem>().GetOwningStation(player.AttachedEntity.Value);
if (stationUid != null)
{
levelNames = GetStationLevelNames(stationUid.Value);
}
}
return(args.Length switch
{
1 => CompletionResult.FromHintOptions(levelNames,
Loc.GetString("cmd-setalertlevel-hint-1")),
2 => CompletionResult.FromHintOptions(CompletionHelper.Booleans,
Loc.GetString("cmd-setalertlevel-hint-2")),
_ => CompletionResult.Empty,
});
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length < 4)
{
return;
}
if (!int.TryParse(args[0], out var x) ||
!int.TryParse(args[1], out var y) ||
!EntityUid.TryParse(args[2], out var gridId) ||
!float.TryParse(args[3], out var temperature))
{
return;
}
if (temperature < Atmospherics.TCMB)
{
shell.WriteLine("Invalid temperature.");
return;
}
if (!_mapManager.TryGetGrid(gridId, out var grid))
{
shell.WriteError("Invalid grid.");
return;
}
var atmospheres = _entities.EntitySysManager.GetEntitySystem <AtmosphereSystem>();
var indices = new Vector2i(x, y);
var tile = atmospheres.GetTileMixture(grid.GridEntityId, null, indices, true);
if (tile == null)
{
shell.WriteLine("Invalid coordinates or tile.");
return;
}
tile.Temperature = temperature;
}
public void Execute(IConsoleShell shell, IPlayerSession player, string[] args)
{
if (args.Length < 1 || args.Length > 2)
{
shell.SendText(player, "Must provide exactly one or two arguments.");
return;
}
var configManager = IoCManager.Resolve <IConfigurationManager>();
var name = args[0];
if (!configManager.IsCVarRegistered(name))
{
shell.SendText(player, $"CVar '{name}' is not registered.");
return;
}
if (args.Length == 1)
{
// Read CVar
var value = configManager.GetCVar <object>(name);
shell.SendText(player, value.ToString());
}
else
{
// Write CVar
var value = args[1];
var type = configManager.GetCVarType(name);
try
{
var parsed = ParseObject(type, value);
configManager.SetCVar(name, parsed);
}
catch (FormatException)
{
shell.SendText(player, $"Input value is in incorrect format for type {type}");
}
}
}
public unsafe void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (!OperatingSystem.IsWindows())
{
shell.WriteError("This command is only supported on Windows.");
return;
}
IDXGIFactory1 *dxgiFactory;
ThrowIfFailed(nameof(CreateDXGIFactory1), CreateDXGIFactory1(__uuidof <IDXGIFactory1>(), (void **)&dxgiFactory));
uint idx = 0;
IDXGIAdapter *adapter;
while (dxgiFactory->EnumAdapters(idx, &adapter) != DXGI_ERROR_NOT_FOUND)
{
DXGI_ADAPTER_DESC2 desc;
IDXGIAdapter3 * adapter3;
adapter->QueryInterface(__uuidof <IDXGIAdapter3>(), (void **)&adapter3);
adapter->Release();
ThrowIfFailed("GetDesc", adapter3->GetDesc2(&desc));
var descString = new ReadOnlySpan <char>(desc.Description, 128).TrimEnd('\0');
shell.WriteLine(descString.ToString());
DXGI_QUERY_VIDEO_MEMORY_INFO memInfo;
adapter3->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &memInfo);
shell.WriteLine($"Usage (local): {ByteHelpers.FormatBytes((long) memInfo.CurrentUsage)}");
adapter3->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &memInfo);
shell.WriteLine($"Usage (non local): {ByteHelpers.FormatBytes((long) memInfo.CurrentUsage)}");
idx += 1;
adapter3->Release();
}
}
