public void TargetOrDefault_disposed_target_returns_null()
{
var weakReference = CreateWeakReferenceToDisposedInstance();
GCHelper.TriggerGC();
Assert.Null(weakReference.TargetOrDefault());
}
public TDelegateInterop Convert()
{
return(GCHelper.ManualFree(releaseGC =>
{
this.releaseGC = releaseGC;
return convert;
}));
}
public void DisposeManagedResources_Finalize()
{
var managedResourcesDisposed = false;
CreateDisposableInstance(() => managedResourcesDisposed = true, null);
GCHelper.TriggerGC();
Assert.False(managedResourcesDisposed);
}
public void DisposeNativeResourcesDisposed_Finalize()
{
var nativeResourcesDisposed = false;
CreateDisposableInstance(null, () => nativeResourcesDisposed = true);
GCHelper.TriggerGC();
Assert.True(nativeResourcesDisposed);
}
private static unsafe void Callback(ManagedLatentCallbackType callbackType, IntPtr thisPtr, IntPtr data)
{
try
{
UUSharpGameplayTask obj = GCHelper.Find <UUSharpGameplayTask>(thisPtr);
switch (callbackType)
{
case ManagedLatentCallbackType.UUSharpGameplayTask_Activate:
obj.OnActivate();
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_InitSimulatedTask:
obj.OnInitSimulatedTask(GCHelper.Find <UGameplayTasksComponent>(data));
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_TickTask:
obj.OnTickTask(*(float *)data);
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_ExternalConfirm:
obj.OnExternalConfirm(*(csbool *)data);
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_ExternalCancel:
obj.OnExternalCancel();
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_GetDebugString:
FStringMarshaler.ToNative(data, obj.OnGetDebugString());
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_OnDestroy:
obj.OnDestroy(*(csbool *)data);
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_Pause:
obj.OnPause();
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_Resume:
obj.OnResume();
break;
case ManagedLatentCallbackType.UUSharpGameplayTask_GenerateDebugDescription:
FStringMarshaler.ToNative(data, obj.OnGenerateDebugDescription());
break;
default:
throw new NotImplementedException();
}
}
catch (Exception e)
{
FMessage.LogException(e);
}
}
void view_Closed(object sender, EventArgs e)
{
var view = sender as IWpfTextView;
view.GotAggregateFocus -= view_GotAggregateFocus;
System.Diagnostics.Debug.Print("document close");
GCHelper.Collect();
}
protected static IGameplayTaskOwnerInterface ConvertToTaskOwner(AActor ownerActor)
{
UObject obj = GCHelper.Find(Native_UUSharpGameplayTask.Internal_ConvertToTaskOwnerActor(ownerActor.Address));
if (obj != null)
{
return(obj.GetInterface <IGameplayTaskOwnerInterface>());
}
return(null);
}
public IGameplayTaskOwnerInterface GetTaskOwner()
{
UObject obj = GCHelper.Find(Native_UGameplayTask.GetTaskOwner(Address));
if (obj != null)
{
return(obj.GetInterface <IGameplayTaskOwnerInterface>());
}
return(null);
}
public static Native.MposClosedCallbackDelegate Callback(Mpos mpos, TaskCompletionSource <bool> source)
{
return(GCHelper.ManualFree <Native.MposClosedCallbackDelegate>(releaseGC =>
{
return (mposPtr, err) =>
{
releaseGC();
return callback(mpos, source, err);
};
}));
}
public static MposFinishTransactionCallbackDelegate Callback(Mpos mpos, TaskCompletionSource <bool> source)
{
return(GCHelper.ManualFree <MposFinishTransactionCallbackDelegate>(releaseGC =>
{
return (mposPtr, err) =>
{
releaseGC();
return callback(mpos, source, err);
};
}));
}
public static MposTablesLoadedCallbackDelegate Callback(Mpos mpos, TaskCompletionSource <Boolean> source)
{
return(GCHelper.ManualFree <MposTablesLoadedCallbackDelegate>(releaseGC =>
{
return (mposPtr, tableError, loaded) =>
{
releaseGC();
return callback(mpos, source, tableError, loaded);
};
}));
}
public static MposTablesLoadedCallbackDelegate Callback(Mpos mpos, int amount, IEnumerable <EmvApplication> applications, PaymentMethod magstripePaymentMethod, TaskCompletionSource <PaymentResult> source)
{
return(GCHelper.ManualFree <MposTablesLoadedCallbackDelegate>(releaseGC =>
{
return (mposPtr, tableError, loaded) =>
{
releaseGC();
return callback(mpos, amount, applications, magstripePaymentMethod, source);
};
}));
}
public static MposGetTableVersionCallbackDelegate Callback(Mpos mpos, MposTablesLoadedCallbackDelegate tableCallback, int amount, PaymentMethod magstripePaymentMethod, TaskCompletionSource <PaymentResult> source)
{
return(GCHelper.ManualFree <MposGetTableVersionCallbackDelegate>(releaseGC =>
{
return (mposPtr, err, version) =>
{
releaseGC();
return callback(mpos, tableCallback, version);
};
}));
}
/// <summary>
/// Обновить кэш аттачей.
/// </summary>
public void Refresh()
{
lock (Locker)
{
loadedAttaches = false;
allAttachments.Clear();
predicatedAttachments.Clear();
GCHelper.Collect();
LoadAttaches();
}
}
public T Execute <T>(Func <T> action)
{
try {
return(ExecuteInner(action));
} catch (InsufficientMemoryException) {
GCHelper.CleanUp();
return(ExecuteInner(action));
} catch (OutOfMemoryException) {
GCHelper.CleanUp();
return(ExecuteInner(action));
}
}
public async Task KeepContextTest()
{
var view = new View();
var collection = new BindingCollection <Context>(view);
var context = new Context();
collection.TrySetContext(context);
var reference = GCHelper.Kill(ref context);
await GCHelper.ForceCollect();
Assert.IsTrue(reference.IsAlive);
}
public async Task DontKeepOwnerTest()
{
var view = new View();
var collection = new BindingCollection <Context>(view);
Assert.IsTrue(collection.IsAlive);
var reference = GCHelper.Kill(ref view);
await GCHelper.ForceCollect();
Assert.IsFalse(collection.IsAlive);
Assert.IsFalse(reference.IsAlive);
}
private ShaderResourceView LoadTexture(string filename)
{
if (_cache.TryGetValue(filename, out var cacheEntry))
{
if (cacheEntry == null)
{
return(null);
}
cacheEntry.UsedId = ++_usedId;
return(cacheEntry.Value);
}
if (!File.Exists(filename))
{
_cache[filename] = null;
return(null);
}
if (_totalSize > OptionMaxCacheSize)
{
// AcToolsLogging.Write($"Limit exceeded: {_totalSize.ToReadableSize()} out of {OptionMaxCacheSize.ToReadableSize()} (cached: {_cache.Count})");
var e = _cache.Values.NonNull().Where(x => x.Key != filename).MinEntryOrDefault(x => x.UsedId);
if (e != null)
{
_totalSize -= e.Size;
_cache.Remove(e.Key);
e.Dispose();
GCHelper.CleanUp();
}
}
ShaderResourceView view;
try {
view = ShaderResourceView.FromFile(Device, filename);
} catch (Exception e) {
AcToolsLogging.Write(e);
_cache[filename] = null;
return(null);
}
cacheEntry = new CacheEntry(filename, view);
_totalSize += cacheEntry.Size;
_cache[filename] = cacheEntry;
cacheEntry.UsedId = ++_usedId;
return(cacheEntry.Value);
}
public static Native.MposPaymentCallbackDelegate Callback(Mpos mpos, TaskCompletionSource <PaymentResult> source)
{
return(GCHelper.ManualFree <Native.MposPaymentCallbackDelegate>(releaseGC =>
{
return (mposPtr, err, info) =>
{
releaseGC();
var instance = new MposPaymentCallback();
instance.info = info;
return instance.handleResult(mpos, source, err);
};
}));
}
public AActor SpawnActor(UClass unrealClass, ref FVector location, ref FRotator rotation, ref FActorSpawnParameters parameters)
{
FActorSpawnParametersInterop interopParams = new FActorSpawnParametersInterop()
{
Name = parameters.Name,
Template = parameters.Template == null ? IntPtr.Zero : parameters.Template.Address,
Owner = parameters.Owner == null ? IntPtr.Zero : parameters.Owner.Address,
Instigator = parameters.Instigator == null ? IntPtr.Zero : parameters.Instigator.Address,
OverrideLevel = parameters.OverrideLevel == null ? IntPtr.Zero : parameters.OverrideLevel.Address,
SpawnCollisionHandlingOverride = parameters.SpawnCollisionHandlingOverride,
PackedBools = parameters.PackedBools,
ObjectFlags = parameters.ObjectFlags
};
return(GCHelper.Find <AActor>(Native_UWorld.SpawnActor(Address, unrealClass.Address, ref location, ref rotation, ref interopParams)));
}
public static MposExtractKeysCallbackDelegate Callback(Mpos mpos, bool forceUpdate, TaskCompletionSource <bool> source)
{
return(GCHelper.ManualFree <MposExtractKeysCallbackDelegate>(releaseGC =>
{
return (mposPtr, err, keyList) =>
{
releaseGC();
var instance = new MposExtractKeysCallback();
instance.keyList = keyList;
return instance.processTables(mpos, forceUpdate, source);
};
}));
}
protected void DestroyServiceHost()
{
CheckDisposed();
lock (_serviceLock)
{
if (!_isServiceLoaded)
{
return;
}
var serviceHost = Interlocked.Exchange(ref _serviceHost, null);
try
{
if (serviceHost != null)
{
UnhookServiceHostEventHandlers(serviceHost);
serviceHost.StopService();
}
}
catch (Exception e)
{
GameLog.Server.General.ErrorFormat("Exception occurred while stopping WCF service: {0}", e.Message);
}
finally
{
_isServiceLoaded = false;
}
var serviceDomain = Interlocked.CompareExchange(ref _serviceDomain, null, null);
if (serviceDomain == null)
{
return;
}
try
{
serviceDomain.UnhandledException -= OnServiceDomainUnhandledException;
GCHelper.Collect();
AppDomain.Unload(serviceDomain);
}
catch (Exception e)
{
GameLog.Server.General.ErrorFormat("Exception occurred while unloading WCF service AppDomain: {0}", e.Message);
}
}
}
private IGameController ResolveGameController()
{
GCHelper.Collect();
var gameController = _container.Resolve <IGameController>();
if (gameController == null)
{
throw new SupremacyException("A game controller could not be created.");
}
if (Interlocked.CompareExchange(ref _gameController, gameController, null) != null)
{
return(_gameController);
}
gameController.Terminated += OnGameControllerTerminated;
return(gameController);
}
public static TmsStoreCallbackDelegate Callback(Mpos mpos, bool forceUpdate, TaskCompletionSource <bool> source)
{
return(GCHelper.ManualFree <TmsStoreCallbackDelegate>(releaseGC =>
{
return (version, capkList, aidList, appList, riskProfileList, acquirerList, userData) =>
{
releaseGC();
var instance = new TmsStoreCallback()
{
capkList = capkList,
aidList = aidList,
appList = appList,
riskProfileList = riskProfileList,
acquirerList = acquirerList
};
return instance.insertDataIntoStorage(mpos, forceUpdate, source, version);
};
}));
}
public override void Dispose()
{
base.Dispose();
foreach (var i in _ready.Values.Where(x => x != null))
{
if (i.Item2?.Disposed == false)
{
i.Item2.Dispose();
}
if (i.Item1?.Disposed == false)
{
i.Item1.EvictionPriority = ResourcePriority.Minimum;
i.Item1.Dispose();
}
}
_ready.Clear();
AcToolsLogging.Write("Textures have been disposed");
GCHelper.CleanUp();
}
private static void Callback(ManagedLatentCallbackType callbackType, IntPtr thisPtr, IntPtr data)
{
try
{
UUSharpOnlineBlueprintCallProxyBase obj = GCHelper.Find <UUSharpOnlineBlueprintCallProxyBase>(thisPtr);
switch (callbackType)
{
case ManagedLatentCallbackType.UUSharpOnlineBlueprintCallProxyBase_Activate:
obj.OnActivate();
break;
case ManagedLatentCallbackType.UUSharpOnlineBlueprintCallProxyBase_BeginDestroy:
obj.OnBeginDestroy();
break;
default:
throw new NotImplementedException();
}
}
catch (Exception e)
{
FMessage.LogException(e);
}
}
private static void Callback(ManagedLatentCallbackType callbackType, IntPtr thisPtr, IntPtr data)
{
try
{
UUSharpAsyncActionBase obj = GCHelper.Find <UUSharpAsyncActionBase>(thisPtr);
switch (callbackType)
{
case ManagedLatentCallbackType.UUSharpAsyncActionBase_Activate:
obj.OnActivate();
break;
case ManagedLatentCallbackType.UUSharpAsyncActionBase_RegisterWithGameInstanceWorldContext:
obj.OnRegisterWithGameInstance(GCHelper.Find(data));
break;
case ManagedLatentCallbackType.UUSharpAsyncActionBase_RegisterWithGameInstance:
obj.OnRegisterWithGameInstance(GCHelper.Find <UGameInstance>(data));
break;
case ManagedLatentCallbackType.UUSharpAsyncActionBase_SetReadyToDestroy:
obj.OnSetReadyToDestroy();
break;
case ManagedLatentCallbackType.UUSharpAsyncActionBase_BeginDestroy:
obj.OnBeginDestroy();
break;
default:
throw new NotImplementedException();
}
}
catch (Exception e)
{
FMessage.LogException(e);
}
}
/// <summary>
/// Register all native functions with managed code
/// </summary>
/// <param name="registerFunctionsAddr">The address of the RegisterFunctions method defined in native code</param>
public static void RegisterFunctions(IntPtr registerFunctionsAddr)
{
if (!EntryPoint.Preloaded)
{
string namespaceName = typeof(NativeFunctions).Namespace;
foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
{
if (type.IsClass && type.IsAbstract && type.IsSealed && type.Name.StartsWith("Native_") && type.Namespace == namespaceName)
{
// Native_FName -> Export_FName_XXXXX
string nativeFunctionPrefix = "Export" + type.Name.Replace("Native", string.Empty) + "_";
foreach (FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static))
{
if (field.IsStatic && field.FieldType.IsSubclassOf(typeof(Delegate)))
{
functions.Add(nativeFunctionPrefix + field.Name, field);
}
}
}
}
// Call the native RegisterFunctions method with our managed RegisterFunction as the callback
Del_RegisterFunctions registerFunctions = (Del_RegisterFunctions)Marshal.GetDelegateForFunctionPointer(
registerFunctionsAddr, typeof(Del_RegisterFunctions));
registerFunctions(Marshal.GetFunctionPointerForDelegate(registerFunction));
// Highest (these may be called from a thread other than the game thread, don't access UObject methods)
FBuild.OnNativeFunctionsRegistered();
FGlobals.OnNativeFunctionsRegistered();
Classes.OnNativeFunctionsRegistered();
BoolMarshaler.OnNativeFunctionsRegistered();
FStringMarshaler.OnNativeFunctionsRegistered();
InputCore.FKey.OnNativeFunctionsRegistered();
FFrame.OnNativeFunctionsRegistered();
// Validate native struct sizes match the managed struct sizes before running any handlers
// NOTE: This MUST come after FStringMarshaler.OnNativeFunctionsRegistered as this requires TCHAR size
StructValidator.ValidateStructs();
}
if (!EntryPoint.Preloading)
{
Debug.Assert(FThreading.IsInGameThread(), "Load/hotreload should be on the game thread");
// Highest = Used for initializing very important data required by other functions.
// VeryHigh = Used for initializing data before UObject classes are loaded.
// High = This is when UObject classes are loaded. Don't access UObjects at this or any higher priority.
// Medium = UObject classes are loaded and available to use at this priority.
// If GEngine is null we need to bind OnPostEngineInit to load anything which requires GEngine
if (FGlobals.GEngine == IntPtr.Zero)
{
FCoreDelegates.OnPostEngineInit.Bind(OnPostEngineInit);
}
// Highest
GCHelper.OnNativeFunctionsRegistered();
FMessage.OnNativeFunctionsRegistered();
Engine.FTimerManagerCache.OnNativeFunctionsRegistered();
WorldTimeHelper.OnNativeFunctionsRegistered();
if (FGlobals.GEngine != IntPtr.Zero)
{
// Needs GEngine for binding delegates
StaticVarManager.OnNativeFunctionsRegistered();
Coroutine.OnNativeFunctionsRegistered();
}
// VeryHigh
NativeReflection.OnNativeFunctionsRegistered();// Requires Classes to be initialized
// High
OnNativeFunctionsRegistered();
// Low
EngineLoop.OnNativeFunctionsRegistered();
// Lowest
CodeGenerator.OnNativeFunctionsRegistered();
#if WITH_USHARP_TESTS
Tests.Tests.OnNativeFunctionsRegistered();
#endif
}
}
private static int MainInner(string[] args)
{
Acd.Factory = new AcdFactory();
var argsFile = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly()?.Location) ?? "", "Arguments.txt");
if (File.Exists(argsFile))
{
args = File.ReadAllLines(argsFile).Concat(args).ToArray();
}
var options = new Options();
if (!Parser.Default.ParseArguments(args, options) || options.Help)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var form = new Form {
Width = 640,
Height = 480,
FormBorderStyle = FormBorderStyle.FixedToolWindow,
StartPosition = FormStartPosition.CenterScreen
};
var message = new TextBox {
Multiline = true,
ReadOnly = true,
BackColor = Control.DefaultBackColor,
BorderStyle = BorderStyle.None,
Text = options.GetUsage(),
Location = new Point(20, 8),
Size = new Size(form.ClientSize.Width - 40, form.ClientSize.Height - 16),
Padding = new Padding(20),
Font = new Font("Consolas", 9f),
TabStop = false
};
var button = new Button {
Text = "OK",
Location = new Point(form.ClientSize.Width / 2 - 80, form.ClientSize.Height - 40),
Size = new Size(160, 32)
};
button.Click += (sender, eventArgs) => form.Close();
form.Controls.Add(button);
form.Controls.Add(message);
form.ShowDialog();
return(1);
}
var filename = Assembly.GetEntryAssembly()?.Location;
if (options.Verbose || filename.IndexOf("log", StringComparison.OrdinalIgnoreCase) != -1 ||
filename.IndexOf("debug", StringComparison.OrdinalIgnoreCase) != -1)
{
// TODO
}
var inputItems = options.Items;
#if DEBUG
inputItems = inputItems.Any() ? inputItems : new[] { DebugHelper.GetCarKn5(), DebugHelper.GetShowroomKn5() };
options.MagickOverride = true;
#endif
if (inputItems.Count == 0)
{
var dialog = new OpenFileDialog {
Title = @"Select KN5",
Filter = @"KN5 Files (*.kn5)|*.kn5"
};
if (dialog.ShowDialog() != DialogResult.OK)
{
return(2);
}
inputItems = new[] { dialog.FileName };
}
var kn5File = inputItems.ElementAtOrDefault(0);
if (kn5File == null || !File.Exists(kn5File))
{
MessageBox.Show(@"File is missing", @"Custom Showroom", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(3);
}
if (options.Mode == Mode.UpdateAmbientShadows)
{
MessageBox.Show("Started");
var sw = Stopwatch.StartNew();
UpdateAmbientShadows(kn5File);
MessageBox.Show($@"Time taken: {sw.Elapsed.TotalSeconds:F2}s");
return(0);
}
if (options.Mode == Mode.ExtractUv)
{
if (string.IsNullOrWhiteSpace(options.ExtractUvTexture))
{
MessageBox.Show(@"Texture to extract is not specified", @"Custom Showroom", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(4);
}
ExtractUv(kn5File, options.ExtractUvTexture);
return(0);
}
var showroomKn5File = inputItems.ElementAtOrDefault(1);
if (showroomKn5File == null && options.ShowroomId != null)
{
showroomKn5File = Path.Combine(
Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(kn5File))) ?? "",
"showroom", options.ShowroomId, options.ShowroomId + ".kn5");
}
if (!File.Exists(showroomKn5File))
{
showroomKn5File = null;
}
if (options.Mode == Mode.Lite)
{
using (var renderer = new ToolsKn5ObjectRenderer(new CarDescription(kn5File))) {
renderer.UseMsaa = options.UseMsaa;
renderer.UseFxaa = options.UseFxaa;
renderer.UseSsaa = options.UseSsaa;
renderer.MagickOverride = options.MagickOverride;
new LiteShowroomFormWrapper(renderer).Run();
}
}
else if (options.Mode == Mode.Dark)
{
using (var renderer = new DarkKn5ObjectRenderer(new CarDescription(kn5File), showroomKn5File)) {
// UI
renderer.UseSprite = true;
renderer.VisibleUi = true;
/*renderer.UseDof = true;
* renderer.UseAccumulationDof = true;
* renderer.AccumulationDofApertureSize = 0f;
* renderer.AccumulationDofBokeh = false;
* renderer.AccumulationDofIterations = 100;*/
#if DEBUG
renderer.AoOpacity = 0.9f;
renderer.AoDebug = true;
renderer.UseAo = true;
renderer.AoType = AoType.Hbao;
/*renderer.BackgroundColor = Color.Black;
* renderer.LightBrightness = 0.2f;
* renderer.AmbientBrightness = 0.2f;
* /*renderer.BackgroundBrightness = 0.02f;
* renderer.FlatMirror = true;*/
/*renderer.FlatMirrorReflectedLight = true;
* renderer.TryToGuessCarLights = true;
*
* renderer.FlatMirrorBlurred = true;
* renderer.FlatMirror = true;*/
//renderer.AddCar(new CarDescription(@"D:\Games\Assetto Corsa\content\cars\ferrari_f40\ferrari_f40.kn5"));
#else
// renderer.FlatMirror = true;
renderer.UseMsaa = options.UseMsaa;
renderer.UseFxaa = options.UseFxaa;
renderer.UseSsaa = options.UseSsaa;
#endif
renderer.MagickOverride = options.MagickOverride;
new LiteShowroomFormWrapper(renderer)
{
ReplaceableShowroom = true
}.Run(() => {
// ReSharper disable once AccessToDisposedClosure
var r = renderer;
if (r.CarNode != null)
{
// r.CarNode.AlignWheelsByData = true;
}
});
}
}
else if (options.Mode == Mode.TrackMap)
{
using (var renderer = new TrackMapPreparationRenderer(kn5File)) {
renderer.UseFxaa = options.UseFxaa;
renderer.SetFilter(new TrackMapRendererFilter());
new BaseKn5FormWrapper(renderer, "Track", 800, 800).Run();
}
}
GCHelper.CleanUp();
return(0);
}
public AActor SpawnActor(UClass unrealClass, ref FVector location, ref FRotator rotation)
{
FActorSpawnParametersInterop parameters = default(FActorSpawnParametersInterop);
return(GCHelper.Find <AActor>(Native_UWorld.SpawnActor(Address, unrealClass.Address, ref location, ref rotation, ref parameters)));
}
