public Alloc Add(int count)
{
Debug.Assert(count > 0);
if (disposed)
{
DisposeHelper.NotifyDisposedUsed(this);
return(new Alloc());
}
Alloc alloc = m_Allocator.Allocate((uint)count);
return(alloc);
}
public void Reset()
{
if (disposed)
{
DisposeHelper.NotifyDisposedUsed(this);
return;
}
// TODO: Re-init should be deferred.
m_Allocator = new BestFitAllocator((uint)m_Length);
UIRUtility.Destroy(m_Atlas);
m_RawAtlas = new RawTexture();
MustCommit = false;
}
public void Reset()
{
if (disposed)
{
DisposeHelper.NotifyDisposedUsed(this);
return;
}
// Actually perform the reset here.
m_Registered.Clear();
m_RenderInfoPool.Clear();
m_GradientRemapPool.Clear();
m_GradientSettingsAtlas.Reset();
}
/// <summary>
/// Application end
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Application_End(object sender, EventArgs e)
{
try
{
LoggerRef.Target.LogInfo("Stopped.");
DisposeHelper.SafeDispose(ref _client);
DisposeHelper.SafeDispose(ref _cache);
}
catch (Exception ex)
{
LoggerRef.Target.LogError(ex);
throw;
}
}
public void Dispose()
{
while (Interlocked.Read(ref _processingNow) > 0)
{
Thread.Sleep(100);
}
if (!_existingRenderer)
{
DisposeHelper.Dispose(ref _renderer);
}
DisposeHelper.Dispose(ref _convertationThreadPool);
}
public static T AddCompiled(string shaderPath, string key, Func <T> compileFunc, Func <string, T> loadFunc)
{
var lastMod = File.GetLastWriteTimeUtc(shaderPath);
ShaderWithDateTime result;
if (s_CompiledShaders.TryGetValue(key, out result) &&
result.LastModified == lastMod)
{
if (result.Shader != null)
{
return(result.Shader);
}
try
{
if (loadFunc != null)
{
return(loadFunc(result.CachePath));
}
}
catch
{
// Recompile if we encounter an error
}
}
if (result != null)
{
DisposeHelper.Dispose(result.Shader);
File.Delete(result.CachePath);
s_CompiledShaders.Remove(key);
}
T shader;
try
{
shader = compileFunc();
}
catch (SharpDX.CompilationException e)
{
throw new SharpDX.CompilationException(e.ResultCode,
"Compilation Error in " + key + "\r\n\r\n" + e.Message);
}
s_CompiledShaders.Add(key, new ShaderWithDateTime(shader, lastMod, loadFunc != null));
return(shader);
}
public void Dispose()
{
DisposeHelper.EnsureAllSteps(
() =>
{
//実行中のものがあれば全て解放する
var workingCommands = this._workingCommands.Keys.ToArray();
foreach (var workingCommand in workingCommands)
{
workingCommand.Dispose();
}
},
() => this._workingCommands.Clear(),
() => this._pool = null); //Pool はお外で管理されてるからここでは参照切るだけ
}
public static void Dispose()
{
foreach (var instance in _instances)
{
DisposeHelper.AttemptDispose(instance.Value);
}
foreach (var instance in _namedInstances)
{
DisposeHelper.AttemptDispose(instance.Value);
}
_instances.Clear();
_namedInstances.Clear();
}
public void BlitOneNow(RenderTexture dst, Texture src, RectInt srcRect, Vector2Int dstPos, bool addBorder, Color tint)
{
if (disposed)
{
DisposeHelper.NotifyDisposedUsed(this);
return;
}
m_SingleBlit[0] = new BlitInfo {
src = src, srcRect = srcRect, dstPos = dstPos, border = addBorder ? 1 : 0, tint = tint
};
BeginBlit(dst);
DoBlit(m_SingleBlit, 0);
EndBlit();
}
protected override void DisposeOverride()
{
DisposeHelper.Dispose(ref _summBlendState);
DisposeHelper.Dispose(ref _bakedBlendState);
DisposeHelper.Dispose(ref _bufferFSumm);
DisposeHelper.Dispose(ref _bufferF1);
DisposeHelper.Dispose(ref _bufferF2);
DisposeHelper.Dispose(ref _bufferA);
DisposeHelper.Dispose(ref _shadowBuffer);
DisposeHelper.Dispose(ref _rasterizerStateFrontCull);
DisposeHelper.Dispose(ref _rasterizerStateBackCull);
CarNode.Dispose();
Scene.Dispose();
base.DisposeOverride();
}
public void Dispose()
{
DisposeHelper.EnsureAllSteps(
() => this.EndTransaction(), //Transaction が生き残っていたら終わらせる
() =>
{
//Connection を Pool に返す
if (this._connection != null)
{
this._pool.ReleaseConnection(this._connection.IndexInPool, this._connection.PayOutNumber);
}
},
() => this._connection = null, //借りてたものをもう使わないという意思表示
() => this._pool = null); //Pool はお外で管理されてるからここでは参照切るだけ
}
public static void FlushTextures()
{
DisposeHelper.DisposeElements(s_OldTextures);
foreach (var texture in s_TempTextures)
{
s_SavedTextures.Remove(texture);
}
s_OldTextures.Clear();
s_OldTextures.AddRange(s_SavedTextures);
s_TempTextures.Clear();
s_SavedTextures.Clear();
}
public override IFilter CreateFilter(IFilter sourceFilter)
{
DisposeHelper.Dispose(ref m_Buffer);
if (!Renderer.IsOpenClAvail || Renderer.RenderQuality == RenderQuality.MaxPerformance)
{
Renderer.FallbackOccurred = true; // Warn user via player stats OSD
return(sourceFilter); // OpenCL is not available, or UNORM8 textures used (not supported); fallback
}
Func <TextureSize, TextureSize> transformWidth = s => new TextureSize(2 * s.Width, s.Height);
Func <TextureSize, TextureSize> transformHeight = s => new TextureSize(s.Width, 2 * s.Height);
var kernel = CompileKernel();
var shaderH = kernel.Configure(transform: transformWidth);
var shaderV = kernel.Configure(transform: transformHeight);
var combine = CompileShader("Combine.hlsl");
var neuronCount = s_NeuronCount[(int)Neurons];
var weights = s_Weights[(int)Neurons];
m_Buffer = Renderer.CreateClBuffer(weights);
var sourceSize = sourceFilter.OutputSize;
if (!IsUpscalingFrom(sourceSize))
{
return(sourceFilter);
}
var yuv = sourceFilter.ConvertToYuv();
var chroma = new ResizeFilter(yuv, new TextureSize(sourceSize.Width * 2, sourceSize.Height * 2),
TextureChannels.ChromaOnly, new Vector2(-0.25f, -0.25f), Renderer.ChromaUpscaler,
Renderer.ChromaDownscaler);
var localWorkSizes = new[] { 8, 8 };
var nnedi3H = new NNedi3HKernelFilter(shaderH, m_Buffer, neuronCount,
new TextureSize(yuv.OutputSize.Width, yuv.OutputSize.Height), localWorkSizes, yuv);
var nnedi3V = new NNedi3VKernelFilter(shaderV,
new TextureSize(nnedi3H.OutputSize.Width, nnedi3H.OutputSize.Height), localWorkSizes, nnedi3H);
var result = new ShaderFilter(combine, nnedi3V, chroma);
return(new ResizeFilter(result.ConvertToRgb(), result.OutputSize, new Vector2(0.5f, 0.5f),
Renderer.LumaUpscaler, Renderer.LumaDownscaler));
}
private void Create3DTexture()
{
if (m_Texture3D != null)
{
// If new 3dlut file was selected, manually dispose resources before we load the new one
if (m_CurrentFileName != FileName)
{
DisposeHelper.Dispose(ref m_Texture3D);
}
else if (m_Texture3D.Valid)
{
return;
}
}
Create3DLut(FileName);
}
public override void Dispose()
{
DisposeHelper.Dispose(ref _bufferF);
DisposeHelper.Dispose(ref _bufferFSsaaFxaa);
DisposeHelper.Dispose(ref _bufferA);
DisposeHelper.Dispose(ref _bufferAColorGrading);
DisposeHelper.Dispose(ref _bufferH1);
DisposeHelper.Dispose(ref _bufferH2);
DisposeHelper.Dispose(ref _colorGradingView);
DisposeHelper.Dispose(ref _colorGradingTexture);
base.Dispose();
}
public void Dispose()
{
DisposeHelper.Dispose(ref _normalDepthState);
DisposeHelper.Dispose(ref _readOnlyDepthState);
DisposeHelper.Dispose(ref _greaterReadOnlyDepthState);
DisposeHelper.Dispose(ref _lessEqualDepthState);
DisposeHelper.Dispose(ref _lessEqualReadOnlyDepthState);
DisposeHelper.Dispose(ref _transparentBlendState);
DisposeHelper.Dispose(ref _addBlendState);
DisposeHelper.Dispose(ref _doubleSidedState);
DisposeHelper.Dispose(ref _doubleSidedSmoothLinesState);
DisposeHelper.Dispose(ref _invertedState);
DisposeHelper.Dispose(ref _wireframeState);
DisposeHelper.Dispose(ref _wireframeInvertedState);
DisposeHelper.Dispose(ref _ambientShadowState);
}
public void Reset()
{
bool disposed = this.disposed;
if (disposed)
{
DisposeHelper.NotifyDisposedUsed(this);
}
else
{
this.m_Allocator = new BestFitAllocator((uint)this.m_Length);
UIRUtility.Destroy(this.m_Atlas);
this.m_RawAtlas = default(GradientSettingsAtlas.RawTexture);
this.MustCommit = false;
}
}
protected override void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (Reader != null)
{
Reader.Dispose();
Reader = null;
}
}
DisposeHelper.OnDispose <OutcomingFileTransfer>(disposing);
disposed = true;
}
}
protected override void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (Writer != null)
{
Writer.Dispose();
Writer = null;
}
}
DisposeHelper.OnDispose <IncomingFileTransfer>(disposing);
disposed = true;
}
}
public static void DisposeAndClear <T>(this T[] source)
{
if (source != null)
{
for (int i = 0; i < source.Length; i++)
//for (int i = source.Length - 1; i >= 0; i--)
{
object o = source[i];
DisposeHelper.DisposeItem(o);
}
/*foreach (object o in source)
* {
* }*/
}
}
public void FlushTextures()
{
foreach (var texture in m_OldTextures)
{
DisposeHelper.Dispose(texture);
}
foreach (var texture in m_TempTextures)
{
m_SavedTextures.Remove(texture);
}
m_OldTextures = m_SavedTextures;
m_TempTextures = new List <ITexture>();
m_SavedTextures = new List <ITexture>();
}
private void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (flushRequired)
{
Flush();
}
msw.Close();
}
DisposeHelper.OnDispose <ClientLogger>(disposing);
disposed = true;
}
}
private async Task CancelBooking()
{
DisposeHelper.Dispose(ref _ui);
if (!IsBooked)
{
return;
}
IsBooked = false;
await Task.Run(() => KunosApiProvider.TryToUnbook(Ip, PortHttp));
if (!_updating)
{
Update(UpdateMode.Lite, true, true).Forget();
}
}
public RenderChain(IPanel panel, Shader standardShader)
{
if (disposed)
{
DisposeHelper.NotifyDisposedUsed(this);
}
this.panel = panel;
device = new UIRenderDevice(Implementation.RenderEvents.ResolveShader(standardShader));
atlasManager = new UIRAtlasManager();
vectorImageManager = new VectorImageManager(atlasManager);
painter = new Implementation.UIRStylePainter(this);
Font.textureRebuilt += OnFontReset;
}
public void Update()
{
var oldFilter = m_Filter;
try
{
DisposeHelper.Dispose(ref m_SourceFilter);
m_Filter = CreateOutputFilter();
UpdateStatus();
}
finally
{
DisposeHelper.Dispose(ref oldFilter);
}
}
private bool Prepare()
{
if (_watcher == null)
{
return(false);
}
Listeners.Purge();
if (Listeners.Any())
{
return(true);
}
DisposeHelper.Dispose(ref _watcher);
Logging.Write("[CarSetupsDirectories.InternalListener] Stop watching…");
return(false);
}
public void Dispose()
{
if (_targetView == null)
{
return;
}
DisposeHelper.Dispose(ref _view);
DisposeHelper.Dispose(ref _depthTargetView);
foreach (var view in _targetView)
{
view.Dispose();
}
_targetView = null;
}
public void ClearCache()
{
DisposeHelper.Dispose(ref _acDbStorage);
DisposeHelper.Dispose(ref _acStorageNew);
DisposeHelper.Dispose(ref _sidekickStorage);
DisposeHelper.Dispose(ref _raceEssentialsStorage);
foreach (var file in Directory.GetFiles(FilesStorage.Instance.GetDirectory("Progress"), "Lap Times (*).data"))
{
if (!FileUtils.ArePathsEqual(Path.GetFileName(file), _cmStorage.Filename))
{
File.Delete(file);
}
}
_lastUpdate = default(DateTime);
}
public void Reset()
{
bool disposed = this.disposed;
if (disposed)
{
DisposeHelper.NotifyDisposedUsed(this);
}
else
{
this.m_Registered.Clear();
this.m_RenderInfoPool.Clear();
this.m_GradientRemapPool.Clear();
this.m_GradientSettingsAtlas.Reset();
this.m_ResetVersion = VectorImageManager.s_GlobalResetVersion;
}
}
protected RenderChain(IPanel panel, UIRenderDevice device, UIRAtlasManager atlasManager)
{
if (disposed)
{
DisposeHelper.NotifyDisposedUsed(this);
}
this.panel = panel;
this.device = device;
this.atlasManager = atlasManager;
if (atlasManager != null)
{
atlasManager.ResetPerformed += OnAtlasReset;
}
painter = new Implementation.UIRStylePainter(this);
Font.textureRebuilt += OnFontReset;
}
public override IEnumerable<IFreeDocument> WriteData(IEnumerable<IFreeDocument> datas)
{
IWorkbook workbook = new XSSFWorkbook();
ISheet sheet1 = workbook.CreateSheet("Sheet1");
FileStream sw = File.Create(FileName);
using (var dis = new DisposeHelper(() =>
{
workbook.Write(sw);
sw.Close();
}))
{
int rowIndex = 0;
PropertyNames = datas.GetKeys().ToDictionary(d => d, d => d);
foreach (IFreeDocument computeable in datas)
{
IDictionary<string, object> data = computeable.DictSerialize();
int cellIndex;
if (rowIndex == 0)
{
IRow row1 = sheet1.CreateRow(rowIndex);
cellIndex = 0;
foreach (var o in this.PropertyNames)
{
row1.CreateCell(cellIndex).SetCellValue(o.Value);
cellIndex++;
}
rowIndex++;
}
cellIndex = 0;
IRow row = sheet1.CreateRow(rowIndex);
foreach (object value in this.PropertyNames.Select(name => data[name.Key]))
{
if (value is DateTime)
{
row.CreateCell(cellIndex).SetCellValue((value.ToString()));
}
else if (value is int || value is long)
{
row.CreateCell(cellIndex).SetCellValue(value.ToString());
}
else if (value is double)
{
row.CreateCell(cellIndex).SetCellValue((double) value);
}
else if (value is string)
{
row.CreateCell(cellIndex).SetCellValue((string) value);
}
else
{
row.CreateCell(cellIndex).SetCellValue(value != null ? value.ToString() : "");
}
cellIndex++;
}
rowIndex++;
yield return computeable;
}
}
}
public static IEnumerable<string> LineRead(string filename, Encoding code = null)
{
FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
StreamReader sr;
sr = code == null ? new StreamReader(fs, true) : new StreamReader(fs, code);
using (var dis = new DisposeHelper(() =>
{
sr.Close();
fs.Close();
}))
{
string ts = sr.ReadLine();
do
{
string t = ts;
yield return t;
ts = sr.ReadLine();
} while (ts != null);
}
}
public override IEnumerable<IFreeDocument> WriteData(IEnumerable<IFreeDocument> datas)
{
var doc = new XmlDocument(); // 创建dom对象
XmlElement root = doc.CreateElement("root");
using (var dis = new DisposeHelper(() =>
{
doc.AppendChild(root);
doc.Save(FileName);
}))
{
foreach (IFreeDocument dictionarySerializable in datas)
{
var doc2 = dictionarySerializable.DictSerialize();
XmlElement newNode = doc.CreateElement(doc2 == null ? "Element" : doc2.Name);
Node2XML(doc2, newNode, doc);
root.AppendChild(newNode);
yield return dictionarySerializable;
}
}
// 保存文件
}
public override IEnumerable<IFreeDocument> WriteData(IEnumerable<IFreeDocument> datas)
{
using (TextWriter streamWriter = new StreamWriter(FileName, false, Encoding.UTF8))
{
using (JsonWriter writer = CreateJsonWriter(streamWriter))
{
int i = 0;
using (var dis = new DisposeHelper(() =>
{
writer.WriteEndArray();
}))
{
writer.WriteStartArray();
foreach (var data in datas)
{
writer.WriteString(GetJsonObject(data).ToString());
yield return data;
i++;
}
}
}
}
}
public LockFile(string filepath)
{
this.filepath = filepath;
this.disposeHelper = new DisposeHelper(this);
}
public override IEnumerable<IFreeDocument> WriteData(IEnumerable<IFreeDocument> datas)
{
if (datas.Any() == false) yield break;
using (var dis = new DisposeHelper(Save))
{
if (PropertyNames == null||PropertyNames.Count==0)
{
PropertyNames = datas.GetKeys().ToDictionary(d => d, d => d);
}
Start(PropertyNames.Values);
var i = 0;
foreach (var computeable in datas)
{
IDictionary<string, object> data = computeable.DictSerialize(Scenario.Report);
var objects = PropertyNames.Select(name => data[name.Key]).ToArray();
WriteData(objects);
i++;
yield return computeable;
}
}
}
