public void RetainRef <TSetter>(AssetBase asset)
{
if (null == _typedAssets)
{
_typedAssets = DictionaryPool <Type, AssetBase> .Get();
}
var type = typeof(TSetter);
if (_typedAssets.ContainsKey(type))
{
Logger.LogVerbose("BundlerMessenger::RetainRef<T>: {0}, Setter exist: {1}, release previous asset: {2}",
this, type.FullName, _typedAssets[type].AssetPath);
_typedAssets[type].Release();
Logger.LogVerbose("BundlerMessenger::RetainRef<T>: {0}, Setter exist: {1}, release previous asset: {2}, finished!",
this, type.FullName, _typedAssets[type].AssetPath);
}
_typedAssets[type] = asset;
Logger.LogVerbose("BundlerMessenger::RetainRef<T>: {0}, loader: {1}", this, asset.Loader);
asset.Retain();
Logger.LogVerbose("BundlerMessenger::RetainRef<T>: {0}, loader: {1}, finished!", this, asset.Loader);
Messengers.Add(this);
}
public static MeshData GenerateTerrainMesh(MapData mapData, int width, int levelOfDetail)
{
var mapInfo = mapData.mapData;
#if UNITY_UV_STARTS_AT_TOP
int btnLeftX = (width - 1) / -2;
int btnLeftZ = (width - 1) / -2;
#else
int topLeftX = (width - 1) / -2;
int topLeftZ = (width - 1) / 2;
#endif
int meshSimplificationIncrement = (levelOfDetail == 0) ? 1 : levelOfDetail * 2;
int verticesPerLine = (width - 1) / meshSimplificationIncrement + 1;
MeshData meshData = DictionaryPool <MeshData> .Get(verticesPerLine);
int vertexIndex = 0;
for (int y = 0; y < width; y += meshSimplificationIncrement)
{
for (int x = 0; x < width; x += meshSimplificationIncrement)
{
var info = mapInfo[y * width + x];
#if UNITY_UV_STARTS_AT_TOP
meshData.vertices[vertexIndex] = new Vector3((btnLeftX + x) / TexMapRate, info.r, (btnLeftZ + y) / TexMapRate);
#else
meshData.vertices[vertexIndex] = new Vector3((topLeftX + x) / TexMapRate, info.r, (topLeftZ - y) / TexMapRate);
#endif
meshData.uvs[vertexIndex] = new Vector2(x / (float)width, y / (float)width);
meshData.nors[vertexIndex] = new Vector3(info.g, info.b, info.a);
vertexIndex++;
}
}
for (int y = 0; y < verticesPerLine - 1; y++)
{
vertexIndex = verticesPerLine * y;
for (int x = 0; x < verticesPerLine - 1; x++)
{
try {
int a00 = vertexIndex;
int a01 = vertexIndex + 1;
int a10 = vertexIndex + verticesPerLine;
int a11 = vertexIndex + verticesPerLine + 1;
#if UNITY_UV_STARTS_AT_TOP
meshData.AddTriangle(a00, a10, a11);
meshData.AddTriangle(a11, a01, a00);
#else
meshData.AddTriangle(a00, a11, a10);
meshData.AddTriangle(a11, a00, a01);
#endif
vertexIndex++;
} catch (Exception) {
Debug.LogError("vertexIndex " + vertexIndex);
throw;
}
}
}
return(meshData);
}
private void SetSizeRootPoints()
{
List <Transform> list = ListPool <Transform> .Get();
((Component)this).get_transform().FindMatchLoop("^fish_point_[0-9]+$", ref list);
if (!((IReadOnlyList <Transform>)list).IsNullOrEmpty <Transform>())
{
Dictionary <int, Transform> toRelease = DictionaryPool <int, Transform> .Get();
int length = 0;
for (int index = 0; index < list.Count; ++index)
{
Transform transform = list[index];
Match match = Regex.Match(((Object)transform).get_name(), "[0-9]+");
int result;
if (match.Success && int.TryParse(match.Value, out result))
{
toRelease[result] = transform;
length = Mathf.Max(length, result + 1);
}
}
this._sizeRootPoints = new Transform[length];
using (Dictionary <int, Transform> .Enumerator enumerator = toRelease.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <int, Transform> current = enumerator.Current;
this._sizeRootPoints[current.Key] = current.Value;
}
}
DictionaryPool <int, Transform> .Release(toRelease);
}
ListPool <Transform> .Release(list);
}
// Token: 0x0600867A RID: 34426 RVA: 0x0034A374 File Offset: 0x00348774
public void CalculateBlendShape()
{
if (FBSTarget.Length == 0)
{
return;
}
var b = correctOpenMax >= 0f ? correctOpenMax : OpenMax;
var num = Mathf.Lerp(OpenMin, b, openRate);
if (0f <= FixedRate)
{
num = FixedRate;
}
var num2 = 0f;
if (blendTimeCtrl != null)
{
num2 = blendTimeCtrl.Calculate();
}
foreach (var fbstargetInfo in FBSTarget)
{
var skinnedMeshRenderer = fbstargetInfo.GetSkinnedMeshRenderer();
var dictionary = DictionaryPool <int, float> .Get();
for (var j = 0; j < fbstargetInfo.PtnSet.Length; j++)
{
dictionary[fbstargetInfo.PtnSet[j].Close] = 0f;
dictionary[fbstargetInfo.PtnSet[j].Open] = 0f;
}
var num3 = (int)Mathf.Clamp(num * 100f, 0f, 100f);
if (num2 != 1f)
{
foreach (var num4 in dictBackFace.Keys)
{
dictionary[fbstargetInfo.PtnSet[num4].Close] = dictionary[fbstargetInfo.PtnSet[num4].Close] + dictBackFace[num4] * (100 - num3) * (1f - num2);
dictionary[fbstargetInfo.PtnSet[num4].Open] = dictionary[fbstargetInfo.PtnSet[num4].Open] + dictBackFace[num4] * num3 * (1f - num2);
}
}
foreach (var num5 in dictNowFace.Keys)
{
dictionary[fbstargetInfo.PtnSet[num5].Close] = dictionary[fbstargetInfo.PtnSet[num5].Close] + dictNowFace[num5] * (100 - num3) * num2;
dictionary[fbstargetInfo.PtnSet[num5].Open] = dictionary[fbstargetInfo.PtnSet[num5].Open] + dictNowFace[num5] * num3 * num2;
}
foreach (var keyValuePair in dictionary)
{
if (keyValuePair.Key != -1)
{
skinnedMeshRenderer.SetBlendShapeWeight(keyValuePair.Key, keyValuePair.Value);
}
}
DictionaryPool <int, float> .Release(dictionary);
}
}
public void CalculateBlendShape()
{
if (this.FBSTarget.Length == 0)
{
return;
}
float num1 = Mathf.Lerp(this.OpenMin, (double)this.correctOpenMax >= 0.0 ? this.correctOpenMax : this.OpenMax, this.openRate);
if (0.0 <= (double)this.FixedRate)
{
num1 = this.FixedRate;
}
float num2 = 0.0f;
if (this.blendTimeCtrl != null)
{
num2 = this.blendTimeCtrl.Calculate();
}
foreach (FBSTargetInfo fbsTargetInfo in this.FBSTarget)
{
SkinnedMeshRenderer skinnedMeshRenderer = fbsTargetInfo.GetSkinnedMeshRenderer();
Dictionary <int, float> toRelease = DictionaryPool <int, float> .Get();
for (int index = 0; index < fbsTargetInfo.PtnSet.Length; ++index)
{
toRelease[fbsTargetInfo.PtnSet[index].Close] = 0.0f;
toRelease[fbsTargetInfo.PtnSet[index].Open] = 0.0f;
}
int num3 = (int)Mathf.Clamp(num1 * 100f, 0.0f, 100f);
if ((double)num2 != 1.0)
{
foreach (int key in this.dictBackFace.Keys)
{
toRelease[fbsTargetInfo.PtnSet[key].Close] = toRelease[fbsTargetInfo.PtnSet[key].Close] + (float)((double)this.dictBackFace[key] * (double)(100 - num3) * (1.0 - (double)num2));
toRelease[fbsTargetInfo.PtnSet[key].Open] = toRelease[fbsTargetInfo.PtnSet[key].Open] + (float)((double)this.dictBackFace[key] * (double)num3 * (1.0 - (double)num2));
}
}
foreach (int key in this.dictNowFace.Keys)
{
toRelease[fbsTargetInfo.PtnSet[key].Close] = toRelease[fbsTargetInfo.PtnSet[key].Close] + this.dictNowFace[key] * (float)(100 - num3) * num2;
toRelease[fbsTargetInfo.PtnSet[key].Open] = toRelease[fbsTargetInfo.PtnSet[key].Open] + this.dictNowFace[key] * (float)num3 * num2;
}
foreach (KeyValuePair <int, float> keyValuePair in toRelease)
{
if (keyValuePair.Key == -1)
{
Debug.LogError((object)(((Object)skinnedMeshRenderer.get_sharedMesh()).get_name() + ": 多分、名前が間違ったデータがある"));
}
else
{
skinnedMeshRenderer.SetBlendShapeWeight(keyValuePair.Key, keyValuePair.Value);
}
}
DictionaryPool <int, float> .Release(toRelease);
}
}
Dictionary <T, U> InitCollection <T, U>(Dictionary <T, U> container)
{
if (container == null)
{
container = DictionaryPool <T, U> .Get();
}
else
{
container.Clear();
}
return(container);
}
public AssetBundleCache(int capacity)
{
_assetBundleInfoDict = DictionaryPool <IgnoreCaseString, AssetBundleInfo> .Get();
_assetbundleDictionary = DictionaryPool <IgnoreCaseString, GameAssetBundle> .Get();
_exceptionHashSet = HashSetPool <IgnoreCaseString> .Get();
_assetbundleincludes = DictionaryPool <string, List <string> > .Get();
_remoteinfo = null;
}
// Token: 0x0600867A RID: 34426 RVA: 0x0034A374 File Offset: 0x00348774
public void CalculateBlendShape()
{
if (this.FBSTarget.Length == 0)
{
return;
}
float b = (this.correctOpenMax >= 0f) ? this.correctOpenMax : this.OpenMax;
float num = Mathf.Lerp(this.OpenMin, b, this.openRate);
if (0f <= this.FixedRate)
{
num = this.FixedRate;
}
float num2 = 0f;
if (this.blendTimeCtrl != null)
{
num2 = this.blendTimeCtrl.Calculate();
}
foreach (FBSTargetInfo fbstargetInfo in this.FBSTarget)
{
SkinnedMeshRenderer skinnedMeshRenderer = fbstargetInfo.GetSkinnedMeshRenderer();
Dictionary <int, float> dictionary = DictionaryPool <int, float> .Get();
for (int j = 0; j < fbstargetInfo.PtnSet.Length; j++)
{
dictionary[fbstargetInfo.PtnSet[j].Close] = 0f;
dictionary[fbstargetInfo.PtnSet[j].Open] = 0f;
}
int num3 = (int)Mathf.Clamp(num * 100f, 0f, 100f);
if (num2 != 1f)
{
foreach (int num4 in this.dictBackFace.Keys)
{
dictionary[fbstargetInfo.PtnSet[num4].Close] = dictionary[fbstargetInfo.PtnSet[num4].Close] + this.dictBackFace[num4] * (float)(100 - num3) * (1f - num2);
dictionary[fbstargetInfo.PtnSet[num4].Open] = dictionary[fbstargetInfo.PtnSet[num4].Open] + this.dictBackFace[num4] * (float)num3 * (1f - num2);
}
}
foreach (int num5 in this.dictNowFace.Keys)
{
dictionary[fbstargetInfo.PtnSet[num5].Close] = dictionary[fbstargetInfo.PtnSet[num5].Close] + this.dictNowFace[num5] * (float)(100 - num3) * num2;
dictionary[fbstargetInfo.PtnSet[num5].Open] = dictionary[fbstargetInfo.PtnSet[num5].Open] + this.dictNowFace[num5] * (float)num3 * num2;
}
foreach (KeyValuePair <int, float> keyValuePair in dictionary)
{
if (keyValuePair.Key != -1)
{
skinnedMeshRenderer.SetBlendShapeWeight(keyValuePair.Key, keyValuePair.Value);
}
}
DictionaryPool <int, float> .Release(dictionary);
}
}
private bool LoadInstrumentAccountSettingData(Guid accountId, Guid instrumentId, DateTime tradeDay, out Dictionary <Guid, InstrumentTradeDaySetting> accountSetting)
{
var reader = DBRepository.Default.GetInstrumentTradeDaySettingData(instrumentId, tradeDay);
accountSetting = null;
if (reader == null)
{
return(false);
}
accountSetting = _pool.Get();
while (reader.Read())
{
Guid eachAccountId = (Guid)reader["AccountID"];
accountSetting.Add(eachAccountId, new InstrumentTradeDaySetting(new DBReader(reader), instrumentId, tradeDay, Settings.Setting.Default));
}
_instrumentSettingsPerTradeDayDict.Add(new InstrumentSettingKey(instrumentId, tradeDay), accountSetting);
return(true);
}
protected int AddGroup(string abGrounpName, string abName)
{
Dictionary <string, int> abReferCount;
if (!m_ABGroups.TryGetValue(abGrounpName, out abReferCount))
{
abReferCount = DictionaryPool <string, int> .Get();
m_ABGroups.Add(abGrounpName, abReferCount);
}
if (!abReferCount.ContainsKey(abName))
{
abReferCount.Add(abName, 1);
return(1);
}
else
{
return(abReferCount[abName]++);
}
}
/// <summary>
/// Generate all shader code from <see cref="GenerateHLSL" /> attribute.
/// </summary>
/// <returns>An awaitable task.</returns>
public static async Task GenerateAll()
{
Dictionary <string, List <ShaderTypeGenerator> > sourceGenerators = null;
try
{
// Store per source file path the generator definitions
sourceGenerators = DictionaryPool <string, List <ShaderTypeGenerator> > .Get();
// Extract all types with the GenerateHLSL tag
foreach (var type in TypeCache.GetTypesWithAttribute <GenerateHLSL>())
{
var attr = type.GetCustomAttributes(typeof(GenerateHLSL), false).First() as GenerateHLSL;
if (!sourceGenerators.TryGetValue(attr.sourcePath, out var generators))
{
generators = ListPool <ShaderTypeGenerator> .Get();
sourceGenerators.Add(attr.sourcePath, generators);
}
generators.Add(new ShaderTypeGenerator(type, attr));
}
// Generate all files
await Task.WhenAll(sourceGenerators.Select(async it =>
await GenerateAsync($"{it.Key}.hlsl", $"{Path.ChangeExtension(it.Key, "custom")}.hlsl", it.Value)));
}
finally
{
// Make sure we always release pooled resources
if (sourceGenerators != null)
{
foreach (var pair in sourceGenerators)
{
ListPool <ShaderTypeGenerator> .Release(pair.Value);
}
DictionaryPool <string, List <ShaderTypeGenerator> > .Release(sourceGenerators);
}
}
}
/// <summary>
/// The last step for loading data.
/// In this step, prototype references are being resolved for this serialized data and their sub data objects.
/// </summary>
/// <param name="prototypes">Prototypes to use for remapping</param>
/// <param name="errors"></param>
public void ResolveReferenceFields(List <IPrototype> prototypes, List <ParsingError> errors, PrototypeParserState state)
{
Dictionary <string, object> updates = DictionaryPool <string, object> .Get();
try
{
foreach (var field in fields)
{
var @ref = field.Value as SerializedPrototypeReference;
if (!ReferenceEquals(@ref, null))
{
updates.Add(field.Key, @ref.Resolve(prototypes));
}
var sub = field.Value as SerializedData;
if (!ReferenceEquals(sub, null))
{
sub.ResolveReferenceFields(prototypes, errors, state);
}
var col = field.Value as SerializedCollectionData;
if (!ReferenceEquals(col, null))
{
col.ResolveReferenceFieldsAndSubData(prototypes, errors, state);
}
}
// Write updates
foreach (var update in updates)
{
this.fields[update.Key] = update.Value;
}
}
finally
{
DictionaryPool <string, object> .Return(updates);
}
}
/// <summary>
/// The last step for loading data.
/// In this step, root references are being resolved for this serialized data and their sub data objects.
/// </summary>
/// <param name="referenceables">Root objects to use for remapping</param>
/// <param name="filename">Only used for error reporting</param>
public void ResolveReferenceFields(string filename, List <ISerializableRoot> referenceables, List <SerializerError> errors, XMLSerializerParams parameters)
{
Dictionary <string, object> updates = DictionaryPool <string, object> .Get();
try
{
foreach (var field in fields)
{
var @ref = field.Value as SerializedRootObjectReference;
if (!ReferenceEquals(@ref, null))
{
updates.Add(field.Key, @ref.Resolve(referenceables));
}
var sub = field.Value as SerializedData;
if (!ReferenceEquals(sub, null))
{
sub.ResolveReferenceFields(filename, referenceables, errors, parameters);
}
var col = field.Value as SerializedCollectionData;
if (!ReferenceEquals(col, null))
{
col.ResolveReferenceFieldsAndSubData(filename, referenceables, errors, parameters);
}
}
// Write updates
foreach (var update in updates)
{
this.fields[update.Key] = update.Value;
}
}
finally
{
DictionaryPool <string, object> .Return(updates);
}
}
private void SaveTrackingFile()
{
Logger.DebugLogDebug($"{nameof(SaveTrackingFile)} fired");
if (!SavePending)
{
return;
}
if (TrackLastLoadedSceneFile == null)
{
throw new NullReferenceException($"{nameof(TrackLastLoadedSceneFile)} should not be null");
}
var prefix = Path.Combine(Paths.CachePath, Path.GetFileName(TrackLastLoadedSceneFile));
var newFile = string.Concat(prefix, Path.GetRandomFileName());
var oldFile = string.Concat(prefix, Path.GetRandomFileName());
var relativeScenes = DictionaryPool <string, string> .Get();
try
{
foreach (var entry in LastLoadedScenes)
{
relativeScenes[SceneRelativePathCache.Get(entry.Key)] =
Path.GetFileName(entry.Value);
}
lock (SavePendingLock)
{
if (!SavePending)
{
return;
}
try
{
using (var fileStream = new FileStream(newFile, FileMode.Create))
using (var streamWriter = new StreamWriter(fileStream, Encoding.UTF8))
{
streamWriter.Write(GUID);
streamWriter.Write(TrackingFileEntrySplit[0]);
streamWriter.Write(Version);
streamWriter.Write(TrackingFileEntrySplit[0]);
streamWriter.Write(relativeScenes.Count);
streamWriter.Write(TrackingFileEntrySplit[0]);
streamWriter.Write('\n');
foreach (var entry in relativeScenes)
{
streamWriter.Write(entry.Key);
streamWriter.Write(TrackingFileEntrySplit[0]);
streamWriter.Write(entry.Value);
streamWriter.Write('\n');
}
}
File.Move(TrackLastLoadedSceneFile, oldFile);
File.Move(newFile, TrackLastLoadedSceneFile);
File.Delete(oldFile);
SavePending = false;
Logger.DebugLogDebug($"Updated {TrackLastLoadedSceneFile}");
}
catch (Exception err)
{
if (!File.Exists(oldFile))
{
throw;
}
Logger.LogException(err, this,
$"{nameof(SaveTrackingFile)}: Error encountered, restoring {TrackLastLoadedSceneFile}");
File.Copy(oldFile, TrackLastLoadedSceneFile);
throw;
}
finally
{
if (File.Exists(oldFile))
{
File.Delete(oldFile);
}
if (File.Exists(newFile))
{
File.Delete(newFile);
}
}
}
}
finally
{
DictionaryPool <string, string> .Release(relativeScenes);
}
}
internal static PooledDictionary <TKey, TValue> Make()
{
return(new PooledDictionary <TKey, TValue>(DictionaryPool.Get()));
}
protected void OnEnable()
{
m_isExpandedById = DictionaryPool <string, bool> .Get();
OnEnableEntityStoreEditor();
}
// Internal validation
// -------------------------------------------------
public override void EvaluateDynamicMaterialSlots()
{
var dynamicInputSlotsToCompare = DictionaryPool <DynamicValueMaterialSlot, ConcreteSlotValueType> .Get();
var skippedDynamicSlots = ListPool <DynamicValueMaterialSlot> .Get();
// iterate the input slots
using (var tempSlots = PooledList <MaterialSlot> .Get())
{
GetInputSlots(tempSlots);
foreach (var inputSlot in tempSlots)
{
inputSlot.hasError = false;
// if there is a connection
var edges = owner.GetEdges(inputSlot.slotReference).ToList();
if (!edges.Any())
{
if (inputSlot is DynamicValueMaterialSlot)
{
skippedDynamicSlots.Add(inputSlot as DynamicValueMaterialSlot);
}
continue;
}
// get the output details
var outputSlotRef = edges[0].outputSlot;
var outputNode = owner.GetNodeFromGuid(outputSlotRef.nodeGuid);
if (outputNode == null)
{
continue;
}
var outputSlot = outputNode.FindOutputSlot <MaterialSlot>(outputSlotRef.slotId);
if (outputSlot == null)
{
continue;
}
if (outputSlot.hasError)
{
inputSlot.hasError = true;
continue;
}
var outputConcreteType = outputSlot.concreteValueType;
// dynamic input... depends on output from other node.
// we need to compare ALL dynamic inputs to make sure they
// are compatable.
if (inputSlot is DynamicValueMaterialSlot)
{
dynamicInputSlotsToCompare.Add((DynamicValueMaterialSlot)inputSlot, outputConcreteType);
continue;
}
}
m_MultiplyType = GetMultiplyType(dynamicInputSlotsToCompare.Values);
// Resolve dynamics depending on matrix/vector configuration
switch (m_MultiplyType)
{
// If all matrix resolve as per dynamic matrix
case MultiplyType.Matrix:
var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicMatrixType);
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(dynamicMatrixType);
}
break;
// If mixed handle differently:
// Iterate all slots and set their concretes based on their edges
// Find matrix slot and convert its type to a vector type
// Reiterate all slots and set non matrix slots to the vector type
case MultiplyType.Mixed:
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
SetConcreteValueTypeFromEdge(dynamicKvP.Key);
}
MaterialSlot matrixSlot = GetMatrixSlot();
ConcreteSlotValueType vectorType = SlotValueHelper.ConvertMatrixToVectorType(matrixSlot.concreteValueType);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
if (dynamicKvP.Key != matrixSlot)
{
dynamicKvP.Key.SetConcreteType(vectorType);
}
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(vectorType);
}
break;
// If all vector resolve as per dynamic vector
default:
var dynamicVectorType = ConvertDynamicVectorInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicVectorType);
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(dynamicVectorType);
}
break;
}
tempSlots.Clear();
GetInputSlots(tempSlots);
bool inputError = tempSlots.Any(x => x.hasError);
if (inputError)
{
owner.AddConcretizationError(guid, string.Format("Node {0} had input error", guid));
hasError = true;
}
// configure the output slots now
// their slotType will either be the default output slotType
// or the above dynanic slotType for dynamic nodes
// or error if there is an input error
tempSlots.Clear();
GetOutputSlots(tempSlots);
foreach (var outputSlot in tempSlots)
{
outputSlot.hasError = false;
if (inputError)
{
outputSlot.hasError = true;
continue;
}
if (outputSlot is DynamicValueMaterialSlot)
{
// Apply similar logic to output slot
switch (m_MultiplyType)
{
// As per dynamic matrix
case MultiplyType.Matrix:
var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
(outputSlot as DynamicValueMaterialSlot).SetConcreteType(dynamicMatrixType);
break;
// Mixed configuration
// Find matrix slot and convert type to vector
// Set output concrete to vector
case MultiplyType.Mixed:
MaterialSlot matrixSlot = GetMatrixSlot();
ConcreteSlotValueType vectorType = SlotValueHelper.ConvertMatrixToVectorType(matrixSlot.concreteValueType);
(outputSlot as DynamicValueMaterialSlot).SetConcreteType(vectorType);
break;
// As per dynamic vector
default:
var dynamicVectorType = ConvertDynamicVectorInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
(outputSlot as DynamicValueMaterialSlot).SetConcreteType(dynamicVectorType);
break;
}
continue;
}
}
tempSlots.Clear();
GetOutputSlots(tempSlots);
if (tempSlots.Any(x => x.hasError))
{
owner.AddConcretizationError(guid, string.Format("Node {0} had output error", guid));
hasError = true;
}
}
CalculateNodeHasError();
ListPool <DynamicValueMaterialSlot> .Release(skippedDynamicSlots);
DictionaryPool <DynamicValueMaterialSlot, ConcreteSlotValueType> .Release(dynamicInputSlotsToCompare);
}
internal static void ExportSelected(LocaleIdentifier source, string dir, string name, XliffVersion version, Dictionary <StringTableCollection, HashSet <int> > collectionsWithSelectedIndexes, ITaskReporter reporter = null)
{
var documents = DictionaryPool <LocaleIdentifier, IXliffDocument> .Get();
try
{
// Used for reporting
int totalTasks = collectionsWithSelectedIndexes.Sum(c => c.Value.Count);
float taskStep = 1.0f / (totalTasks * 2.0f);
float progress = 0;
reporter?.Start($"Exporting {totalTasks} String Tables to XLIFF", string.Empty);
foreach (var kvp in collectionsWithSelectedIndexes)
{
var stringTableCollection = kvp.Key;
var sourceTable = stringTableCollection.GetTable(source) as StringTable;
if (sourceTable == null)
{
var message = $"Collection {stringTableCollection.TableCollectionName} does not contain a table for the source language {source}";
reporter?.Fail(message);
throw new Exception(message);
}
foreach (var stringTableIndex in kvp.Value)
{
var stringTable = stringTableCollection.StringTables[stringTableIndex];
reporter?.ReportProgress($"Generating document for {stringTable.name}", progress);
progress += taskStep;
if (!documents.TryGetValue(stringTable.LocaleIdentifier, out var targetDoc))
{
targetDoc = CreateDocument(source, stringTable.LocaleIdentifier, version);
documents[stringTable.LocaleIdentifier] = targetDoc;
}
AddTableToDocument(targetDoc, sourceTable, stringTable);
}
}
// Now write the files
foreach (var doc in documents)
{
var cleanName = CleanFileName(name);
var fileName = $"{cleanName}_{doc.Key.Code}.xlf";
var filePath = Path.Combine(dir, fileName);
reporter?.ReportProgress($"Writing {fileName}", progress);
progress += taskStep;
using (var stream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
doc.Value.Serialize(stream);
}
}
reporter?.Completed($"Finished exporting");
}
catch (Exception e)
{
reporter?.Fail(e.Message);
throw;
}
finally
{
DictionaryPool <LocaleIdentifier, IXliffDocument> .Release(documents);
}
}
internal static GenericMenu BuildPopupList(Object target, UnityEventBase dummyEvent, SerializedProperty listener)
{
//special case for components... we want all the game objects targets there!
var targetToUse = target;
if (targetToUse is Component)
{
targetToUse = (target as Component).gameObject;
}
// find the current event target...
var methodName = listener.FindPropertyRelative(kMethodNamePath);
var menu = new GenericMenu();
menu.AddItem(new GUIContent(kNoFunctionString),
string.IsNullOrEmpty(methodName.stringValue),
ClearEventFunction,
new UnityEventFunction(listener, null, null, PersistentListenerMode.EventDefined));
if (targetToUse == null)
{
return(menu);
}
menu.AddSeparator("");
// figure out the signature of this delegate...
// The property at this stage points to the 'container' and has the field name
Type delegateType = dummyEvent.GetType();
// check out the signature of invoke as this is the callback!
MethodInfo delegateMethod = delegateType.GetMethod("Invoke");
var delegateArgumentsTypes = delegateMethod.GetParameters().Select(x => x.ParameterType).ToArray();
var duplicateNames = DictionaryPool <string, int> .Get();
var duplicateFullNames = DictionaryPool <string, int> .Get();
GeneratePopUpForType(menu, targetToUse, targetToUse.GetType().Name, listener, delegateArgumentsTypes);
duplicateNames[targetToUse.GetType().Name] = 0;
if (targetToUse is GameObject)
{
Component[] comps = (targetToUse as GameObject).GetComponents <Component>();
// Collect all the names and record how many times the same name is used.
foreach (Component comp in comps)
{
var duplicateIndex = 0;
if (duplicateNames.TryGetValue(comp.GetType().Name, out duplicateIndex))
{
duplicateIndex++;
}
duplicateNames[comp.GetType().Name] = duplicateIndex;
}
foreach (Component comp in comps)
{
if (comp == null)
{
continue;
}
var compType = comp.GetType();
string targetName = compType.Name;
int duplicateIndex = 0;
// Is this name used multiple times? If so then use the full name plus an index if there are also duplicates of this. (case 1309997)
if (duplicateNames[compType.Name] > 0)
{
if (duplicateFullNames.TryGetValue(compType.FullName, out duplicateIndex))
{
targetName = $"{compType.FullName} ({duplicateIndex})";
}
else
{
targetName = compType.FullName;
}
}
GeneratePopUpForType(menu, comp, targetName, listener, delegateArgumentsTypes);
duplicateFullNames[compType.FullName] = duplicateIndex + 1;
}
DictionaryPool <string, int> .Release(duplicateNames);
DictionaryPool <string, int> .Release(duplicateFullNames);
}
return(menu);
}
private static void FreeHUpdateUI()
{
// for 3P the character names show in one extra place that the standard check doesn't cover.
// easiest to just update each time.
var freeHScene = Object.FindObjectOfType <FreeHScene>();
if (freeHScene == null)
{
return;
}
var member = Traverse.Create(freeHScene).Field <FreeHScene.Member>("member")?.Value;
if (member == null)
{
return;
}
Action <string> GetUpdateUIField(string fieldName)
{
void Callback(string value)
{
if (string.IsNullOrEmpty(value) || freeHScene == null)
{
return;
}
var field = Traverse.Create(freeHScene).Field <TextMeshProUGUI>(fieldName)?.Value;
if (field == null)
{
return;
}
field.text = value;
}
return(Callback);
}
Action <string> GetUpdateTextCallback(string path)
{
void Callback(string value)
{
if (string.IsNullOrEmpty(value))
{
return;
}
var obj = GameObject.Find(path);
if (obj == null)
{
return;
}
var uiText = obj.GetComponent <Text>();
if (uiText == null)
{
return;
}
uiText.text = value;
}
return(Callback);
}
var callbackMap = DictionaryPool <SaveData.Heroine, List <Action <string> > > .Get();
try
{
if (member.resultHeroine.HasValue && member.resultHeroine.Value != null)
{
if (!callbackMap.TryGetValue(member.resultHeroine.Value, out var callbacks))
{
callbackMap[member.resultHeroine.Value] =
callbacks = GeBoCommon.Utilities.ListPool <Action <string> > .Get();
}
callbacks.Add(GetUpdateUIField("textFemaleName1"));
}
if (member.resultPartner.HasValue && member.resultPartner.Value != null)
{
if (!callbackMap.TryGetValue(member.resultPartner.Value, out var callbacks))
{
callbackMap[member.resultPartner.Value] =
callbacks = GeBoCommon.Utilities.ListPool <Action <string> > .Get();
}
callbacks.Add(GetUpdateUIField("textFemaleName2"));
}
// leaving traverse to work with earlier versions
var resultDarkHeroine = Traverse.Create(member)
.Field <ReactiveProperty <SaveData.Heroine> >("resultDarkHeroine")?.Value;
if (resultDarkHeroine != null && resultDarkHeroine.HasValue && resultDarkHeroine.Value != null)
{
if (!callbackMap.TryGetValue(resultDarkHeroine.Value, out var callbacks))
{
callbackMap[resultDarkHeroine.Value] =
callbacks = GeBoCommon.Utilities.ListPool <Action <string> > .Get();
}
callbacks.Add(
// ReSharper disable once StringLiteralTypo
GetUpdateTextCallback("/FreeHScene/Canvas/Panel/Dark/FemaleInfomation/Name/TextMeshPro Text"));
}
foreach (var entry in callbackMap)
{
foreach (var heroineChaFile in entry.Key.GetRelatedChaFiles())
{
heroineChaFile.TranslateFullName(
translated =>
{
foreach (var callback in entry.Value)
{
try
{
callback(translated);
}
catch (Exception err)
{
Logger.LogException(err, freeHScene, nameof(FreeHUpdateUI));
}
}
});
}
}
}
finally
{
foreach (var entry in callbackMap)
{
GeBoCommon.Utilities.ListPool <Action <string> > .Release(entry.Value);
}
DictionaryPool <SaveData.Heroine, List <Action <string> > > .Release(callbackMap);
}
}
// Internal validation
// -------------------------------------------------
public override void ValidateNode()
{
var isInError = false;
// all children nodes needs to be updated first
// so do that here
var slots = ListPool <MaterialSlot> .Get();
GetInputSlots(slots);
foreach (var inputSlot in slots)
{
inputSlot.hasError = false;
var edges = owner.GetEdges(inputSlot.slotReference);
foreach (var edge in edges)
{
var fromSocketRef = edge.outputSlot;
var outputNode = owner.GetNodeFromGuid(fromSocketRef.nodeGuid);
if (outputNode == null)
{
continue;
}
outputNode.ValidateNode();
if (outputNode.hasError)
{
isInError = true;
}
}
}
ListPool <MaterialSlot> .Release(slots);
var dynamicInputSlotsToCompare = DictionaryPool <DynamicValueMaterialSlot, ConcreteSlotValueType> .Get();
var skippedDynamicSlots = ListPool <DynamicValueMaterialSlot> .Get();
// iterate the input slots
s_TempSlots.Clear();
GetInputSlots(s_TempSlots);
foreach (var inputSlot in s_TempSlots)
{
// if there is a connection
var edges = owner.GetEdges(inputSlot.slotReference).ToList();
if (!edges.Any())
{
if (inputSlot is DynamicValueMaterialSlot)
{
skippedDynamicSlots.Add(inputSlot as DynamicValueMaterialSlot);
}
continue;
}
// get the output details
var outputSlotRef = edges[0].outputSlot;
var outputNode = owner.GetNodeFromGuid(outputSlotRef.nodeGuid);
if (outputNode == null)
{
continue;
}
var outputSlot = outputNode.FindOutputSlot <MaterialSlot>(outputSlotRef.slotId);
if (outputSlot == null)
{
continue;
}
if (outputSlot.hasError)
{
inputSlot.hasError = true;
continue;
}
var outputConcreteType = outputSlot.concreteValueType;
// dynamic input... depends on output from other node.
// we need to compare ALL dynamic inputs to make sure they
// are compatable.
if (inputSlot is DynamicValueMaterialSlot)
{
dynamicInputSlotsToCompare.Add((DynamicValueMaterialSlot)inputSlot, outputConcreteType);
continue;
}
// if we have a standard connection... just check the types work!
if (!ImplicitConversionExists(outputConcreteType, inputSlot.concreteValueType))
{
inputSlot.hasError = true;
}
}
m_MultiplyType = GetMultiplyType(dynamicInputSlotsToCompare.Values);
// Resolve dynamics depending on matrix/vector configuration
switch (m_MultiplyType)
{
// If all matrix resolve as per dynamic matrix
case MultiplyType.Matrix:
var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicMatrixType);
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(dynamicMatrixType);
}
break;
// If mixed handle differently:
// Iterate all slots and set their concretes based on their edges
// Find matrix slot and convert its type to a vector type
// Reiterate all slots and set non matrix slots to the vector type
case MultiplyType.Mixed:
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
SetConcreteValueTypeFromEdge(dynamicKvP.Key);
}
MaterialSlot matrixSlot = GetMatrixSlot();
ConcreteSlotValueType vectorType = SlotValueHelper.ConvertMatrixToVectorType(matrixSlot.concreteValueType);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
if (dynamicKvP.Key != matrixSlot)
{
dynamicKvP.Key.SetConcreteType(vectorType);
}
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(vectorType);
}
break;
// If all vector resolve as per dynamic vector
default:
var dynamicVectorType = ConvertDynamicInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicVectorType);
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(dynamicVectorType);
}
break;
}
s_TempSlots.Clear();
GetInputSlots(s_TempSlots);
var inputError = s_TempSlots.Any(x => x.hasError);
// configure the output slots now
// their slotType will either be the default output slotType
// or the above dynanic slotType for dynamic nodes
// or error if there is an input error
s_TempSlots.Clear();
GetOutputSlots(s_TempSlots);
foreach (var outputSlot in s_TempSlots)
{
outputSlot.hasError = false;
if (inputError)
{
outputSlot.hasError = true;
continue;
}
if (outputSlot is DynamicValueMaterialSlot)
{
// Apply similar logic to output slot
switch (m_MultiplyType)
{
// As per dynamic matrix
case MultiplyType.Matrix:
var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
(outputSlot as DynamicValueMaterialSlot).SetConcreteType(dynamicMatrixType);
break;
// Mixed configuration
// Find matrix slot and convert type to vector
// Set output concrete to vector
case MultiplyType.Mixed:
MaterialSlot matrixSlot = GetMatrixSlot();
ConcreteSlotValueType vectorType = SlotValueHelper.ConvertMatrixToVectorType(matrixSlot.concreteValueType);
(outputSlot as DynamicValueMaterialSlot).SetConcreteType(vectorType);
break;
// As per dynamic vector
default:
var dynamicVectorType = ConvertDynamicInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
(outputSlot as DynamicValueMaterialSlot).SetConcreteType(dynamicVectorType);
break;
}
continue;
}
}
isInError |= inputError;
s_TempSlots.Clear();
GetOutputSlots(s_TempSlots);
isInError |= s_TempSlots.Any(x => x.hasError);
isInError |= CalculateNodeHasError();
hasError = isInError;
if (!hasError)
{
++version;
}
ListPool <DynamicValueMaterialSlot> .Release(skippedDynamicSlots);
DictionaryPool <DynamicValueMaterialSlot, ConcreteSlotValueType> .Release(dynamicInputSlotsToCompare);
}
public override void EvaluateDynamicMaterialSlots(List <MaterialSlot> inputSlots, List <MaterialSlot> outputSlots)
{
var dynamicInputSlotsToCompare = DictionaryPool <DynamicVectorMaterialSlot, ConcreteSlotValueType> .Get();
var skippedDynamicSlots = ListPool <DynamicVectorMaterialSlot> .Get();
var dynamicMatrixInputSlotsToCompare = DictionaryPool <DynamicMatrixMaterialSlot, ConcreteSlotValueType> .Get();
var skippedDynamicMatrixSlots = ListPool <DynamicMatrixMaterialSlot> .Get();
// iterate the input slots
{
foreach (var inputSlot in inputSlots)
{
inputSlot.hasError = false;
// if there is a connection
var edges = owner.GetEdges(inputSlot.slotReference).ToList();
if (!edges.Any())
{
if (inputSlot is DynamicVectorMaterialSlot)
{
skippedDynamicSlots.Add(inputSlot as DynamicVectorMaterialSlot);
}
if (inputSlot is DynamicMatrixMaterialSlot)
{
skippedDynamicMatrixSlots.Add(inputSlot as DynamicMatrixMaterialSlot);
}
continue;
}
// get the output details
var outputSlotRef = edges[0].outputSlot;
var outputNode = outputSlotRef.node;
if (outputNode == null)
{
continue;
}
var outputSlot = outputNode.FindOutputSlot <MaterialSlot>(outputSlotRef.slotId);
if (outputSlot == null)
{
continue;
}
if (outputSlot.hasError)
{
inputSlot.hasError = true;
continue;
}
var outputConcreteType = outputSlot.concreteValueType;
// dynamic input... depends on output from other node.
// we need to compare ALL dynamic inputs to make sure they
// are compatable.
if (inputSlot is DynamicVectorMaterialSlot)
{
dynamicInputSlotsToCompare.Add((DynamicVectorMaterialSlot)inputSlot, outputConcreteType);
continue;
}
else if (inputSlot is DynamicMatrixMaterialSlot)
{
dynamicMatrixInputSlotsToCompare.Add((DynamicMatrixMaterialSlot)inputSlot, outputConcreteType);
continue;
}
}
// and now dynamic matrices
var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicMatrixInputSlotsToCompare.Values);
foreach (var dynamicKvP in dynamicMatrixInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicMatrixType);
}
foreach (var skippedSlot in skippedDynamicMatrixSlots)
{
skippedSlot.SetConcreteType(dynamicMatrixType);
}
// we can now figure out the dynamic slotType
// from here set all the
var dynamicType = SlotValueHelper.ConvertMatrixToVectorType(dynamicMatrixType);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicType);
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(dynamicType);
}
bool inputError = inputSlots.Any(x => x.hasError);
if (inputError)
{
owner.AddConcretizationError(objectId, string.Format("Node {0} had input error", objectId));
hasError = true;
}
// configure the output slots now
// their slotType will either be the default output slotType
// or the above dynanic slotType for dynamic nodes
// or error if there is an input error
foreach (var outputSlot in outputSlots)
{
outputSlot.hasError = false;
if (inputError)
{
outputSlot.hasError = true;
continue;
}
if (outputSlot is DynamicVectorMaterialSlot)
{
(outputSlot as DynamicVectorMaterialSlot).SetConcreteType(dynamicType);
continue;
}
else if (outputSlot is DynamicMatrixMaterialSlot)
{
(outputSlot as DynamicMatrixMaterialSlot).SetConcreteType(dynamicMatrixType);
continue;
}
}
if (outputSlots.Any(x => x.hasError))
{
owner.AddConcretizationError(objectId, string.Format("Node {0} had output error", objectId));
hasError = true;
}
}
CalculateNodeHasError();
ListPool <DynamicVectorMaterialSlot> .Release(skippedDynamicSlots);
DictionaryPool <DynamicVectorMaterialSlot, ConcreteSlotValueType> .Release(dynamicInputSlotsToCompare);
ListPool <DynamicMatrixMaterialSlot> .Release(skippedDynamicMatrixSlots);
DictionaryPool <DynamicMatrixMaterialSlot, ConcreteSlotValueType> .Release(dynamicMatrixInputSlotsToCompare);
}
public override void ValidateNode()
{
var isInError = false;
var errorMessage = k_validationErrorMessage;
var dynamicInputSlotsToCompare = DictionaryPool <DynamicVectorMaterialSlot, ConcreteSlotValueType> .Get();
var skippedDynamicSlots = ListPool <DynamicVectorMaterialSlot> .Get();
var dynamicMatrixInputSlotsToCompare = DictionaryPool <DynamicMatrixMaterialSlot, ConcreteSlotValueType> .Get();
var skippedDynamicMatrixSlots = ListPool <DynamicMatrixMaterialSlot> .Get();
// iterate the input slots
s_TempSlots.Clear();
GetInputSlots(s_TempSlots);
foreach (var inputSlot in s_TempSlots)
{
inputSlot.hasError = false;
// if there is a connection
var edges = owner.GetEdges(inputSlot.slotReference).ToList();
if (!edges.Any())
{
if (inputSlot is DynamicVectorMaterialSlot)
{
skippedDynamicSlots.Add(inputSlot as DynamicVectorMaterialSlot);
}
if (inputSlot is DynamicMatrixMaterialSlot)
{
skippedDynamicMatrixSlots.Add(inputSlot as DynamicMatrixMaterialSlot);
}
continue;
}
// get the output details
var outputSlotRef = edges[0].outputSlot;
var outputNode = owner.GetNodeFromGuid(outputSlotRef.nodeGuid);
if (outputNode == null)
{
continue;
}
var outputSlot = outputNode.FindOutputSlot <MaterialSlot>(outputSlotRef.slotId);
if (outputSlot == null)
{
continue;
}
if (outputSlot.hasError)
{
inputSlot.hasError = true;
continue;
}
var outputConcreteType = outputSlot.concreteValueType;
// dynamic input... depends on output from other node.
// we need to compare ALL dynamic inputs to make sure they
// are compatable.
if (inputSlot is DynamicVectorMaterialSlot)
{
dynamicInputSlotsToCompare.Add((DynamicVectorMaterialSlot)inputSlot, outputConcreteType);
continue;
}
else if (inputSlot is DynamicMatrixMaterialSlot)
{
dynamicMatrixInputSlotsToCompare.Add((DynamicMatrixMaterialSlot)inputSlot, outputConcreteType);
continue;
}
}
// and now dynamic matrices
var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicMatrixInputSlotsToCompare.Values);
foreach (var dynamicKvP in dynamicMatrixInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicMatrixType);
}
foreach (var skippedSlot in skippedDynamicMatrixSlots)
{
skippedSlot.SetConcreteType(dynamicMatrixType);
}
// we can now figure out the dynamic slotType
// from here set all the
var dynamicType = SlotValueHelper.ConvertMatrixToVectorType(dynamicMatrixType);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicType);
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(dynamicType);
}
s_TempSlots.Clear();
GetInputSlots(s_TempSlots);
var inputError = s_TempSlots.Any(x => x.hasError);
// configure the output slots now
// their slotType will either be the default output slotType
// or the above dynanic slotType for dynamic nodes
// or error if there is an input error
s_TempSlots.Clear();
GetOutputSlots(s_TempSlots);
foreach (var outputSlot in s_TempSlots)
{
outputSlot.hasError = false;
if (inputError)
{
outputSlot.hasError = true;
continue;
}
if (outputSlot is DynamicVectorMaterialSlot)
{
(outputSlot as DynamicVectorMaterialSlot).SetConcreteType(dynamicType);
continue;
}
else if (outputSlot is DynamicMatrixMaterialSlot)
{
(outputSlot as DynamicMatrixMaterialSlot).SetConcreteType(dynamicMatrixType);
continue;
}
}
isInError |= inputError;
s_TempSlots.Clear();
GetOutputSlots(s_TempSlots);
isInError |= s_TempSlots.Any(x => x.hasError);
isInError |= CalculateNodeHasError(ref errorMessage);
isInError |= ValidateConcretePrecision(ref errorMessage);
hasError = isInError;
if (isInError)
{
((GraphData)owner).AddValidationError(tempId, errorMessage);
}
else
{
++version;
}
ListPool <DynamicVectorMaterialSlot> .Release(skippedDynamicSlots);
DictionaryPool <DynamicVectorMaterialSlot, ConcreteSlotValueType> .Release(dynamicInputSlotsToCompare);
ListPool <DynamicMatrixMaterialSlot> .Release(skippedDynamicMatrixSlots);
DictionaryPool <DynamicMatrixMaterialSlot, ConcreteSlotValueType> .Release(dynamicMatrixInputSlotsToCompare);
}
public List <Callback> GenerateDependencyGraph()
{
var callbacks = GetCallbacks();
var packageLookup = DictionaryPool <string, List <Callback> > .Get();
var assemblyLookup = DictionaryPool <string, List <Callback> > .Get();
var classLookup = DictionaryPool <Type, Callback> .Get();
// First generate our lookups for class, assembly and package.
foreach (var cb in callbacks)
{
classLookup[cb.classType] = cb;
var assemblyName = cb.classType.Assembly.GetName().Name;
if (!assemblyLookup.TryGetValue(assemblyName, out var assemblies))
{
assemblies = new List <Callback>();
assemblyLookup[assemblyName] = assemblies;
}
assemblies.Add(cb);
var package = cb.packageName;
if (package != null)
{
if (!packageLookup.TryGetValue(package, out var packages))
{
packages = new List <Callback>();
packageLookup[package] = packages;
}
packages.Add(cb);
}
}
// Sort the methods so that the output order is deterministic.
callbacks.Sort();
// Now connect the dependency graph nodes
foreach (var dependency in callbacks)
{
// Dependency by class
foreach (var runAfter in dependency.GetCustomAttributes <RunAfterClassAttribute>())
{
// Ignore classes that may not exist in the project
if (runAfter.classType == null)
{
continue;
}
if (classLookup.TryGetValue(runAfter.classType, out var runAfterMethodInfo))
{
dependency.AddIncomingConnection(runAfterMethodInfo);
}
}
foreach (var runBefore in dependency.GetCustomAttributes <RunBeforeClassAttribute>())
{
// Ignore classes that may not exist in the project
if (runBefore.classType == null)
{
continue;
}
if (classLookup.TryGetValue(runBefore.classType, out var runBeforeMethodInfo))
{
dependency.AddOutgoingConnection(runBeforeMethodInfo);
}
}
// Dependency by package
foreach (var runAfter in dependency.GetCustomAttributes <RunAfterPackageAttribute>())
{
if (packageLookup.TryGetValue(runAfter.packageName, out var runAfterMethodInfos))
{
dependency.AddIncomingConnections(runAfterMethodInfos);
}
}
foreach (var runBefore in dependency.GetCustomAttributes <RunBeforePackageAttribute>())
{
if (packageLookup.TryGetValue(runBefore.packageName, out var runBeforeMethodInfos))
{
dependency.AddOutgoingConnections(runBeforeMethodInfos);
}
}
// Dependency by Assembly
foreach (var runAfter in dependency.GetCustomAttributes <RunAfterAssemblyAttribute>())
{
if (assemblyLookup.TryGetValue(runAfter.assemblyName, out var runAfterMethodInfos))
{
dependency.AddIncomingConnections(runAfterMethodInfos);
}
}
foreach (var runBefore in dependency.GetCustomAttributes <RunBeforeAssemblyAttribute>())
{
if (assemblyLookup.TryGetValue(runBefore.assemblyName, out var runBeforeMethodInfos))
{
dependency.AddOutgoingConnections(runBeforeMethodInfos);
}
}
}
DictionaryPool <string, List <Callback> > .Release(packageLookup);
DictionaryPool <string, List <Callback> > .Release(assemblyLookup);
DictionaryPool <Type, Callback> .Release(classLookup);
return(callbacks);
}
private void SettingInventoryFilter()
{
Manager.Resources resources = !Singleton <Manager.Resources> .IsInstance() ? (Manager.Resources)null : Singleton <Manager.Resources> .Instance;
PlayerActor playerActor = !Singleton <Manager.Map> .IsInstance() ? (PlayerActor)null : Singleton <Manager.Map> .Instance.Player;
if (Object.op_Equality((Object)resources, (Object)null) || Object.op_Equality((Object)playerActor, (Object)null))
{
return;
}
PetHomePoint.HomeKind kind = this._currentPetHomePoint.Kind;
Dictionary <int, List <ValueTuple <ItemIDKeyPair, int> > > petItemInfoTable = resources.AnimalTable.PetItemInfoTable;
int key = (int)kind;
InventoryFacadeViewer.ItemFilter[] itemFilter1 = (InventoryFacadeViewer.ItemFilter[])null;
if (!this._itemFilterTable.TryGetValue(key, out itemFilter1))
{
List <ValueTuple <ItemIDKeyPair, int> > valueTupleList;
petItemInfoTable.TryGetValue(key, out valueTupleList);
if (!((IReadOnlyList <ValueTuple <ItemIDKeyPair, int> >)valueTupleList).IsNullOrEmpty <ValueTuple <ItemIDKeyPair, int> >())
{
Dictionary <int, List <int> > toRelease = DictionaryPool <int, List <int> > .Get();
using (List <ValueTuple <ItemIDKeyPair, int> > .Enumerator enumerator = valueTupleList.GetEnumerator())
{
while (enumerator.MoveNext())
{
ItemIDKeyPair itemIdKeyPair = (ItemIDKeyPair)enumerator.Current.Item1;
List <int> intList1;
if (!toRelease.TryGetValue(itemIdKeyPair.categoryID, out intList1) || intList1 == null)
{
List <int> intList2 = ListPool <int> .Get();
toRelease[itemIdKeyPair.categoryID] = intList2;
intList1 = intList2;
}
intList1.Add(itemIdKeyPair.itemID);
}
}
InventoryFacadeViewer.ItemFilter[] itemFilter2 = new InventoryFacadeViewer.ItemFilter[toRelease.Count];
int index1 = 0;
foreach (KeyValuePair <int, List <int> > keyValuePair in toRelease)
{
int[] IDs = new int[keyValuePair.Value.Count];
for (int index2 = 0; index2 < IDs.Length; ++index2)
{
IDs[index2] = keyValuePair.Value[index2];
}
itemFilter2[index1] = new InventoryFacadeViewer.ItemFilter(keyValuePair.Key, IDs);
++index1;
}
List <int> list = toRelease.Keys.ToList <int>();
for (int index2 = 0; index2 < list.Count; ++index2)
{
ListPool <int> .Release(toRelease[list[index2]]);
}
DictionaryPool <int, List <int> > .Release(toRelease);
this._itemFilterTable[key] = itemFilter2;
this._inventoryUI.SetItemFilter(itemFilter2);
}
else
{
this._itemFilterTable[key] = this._emptyFilter;
this._inventoryUI.SetItemFilter(this._emptyFilter);
}
}
else
{
this._inventoryUI.SetItemFilter(itemFilter1);
}
}
private void HandleDirectionMove(Direction scanDirection, Vector2Int negativeEndPosition, Vector2Int positiveEndPosition, Stack <Command> tickCommands, bool canBounce)
{
var scanDisplacement = DirectionUtils.DirectionToDisplacement(scanDirection);
var impactBlocks = DictionaryPool <Block, int> .Get();
for (var position = negativeEndPosition + scanDisplacement; position != positiveEndPosition; position += scanDisplacement)
{
var blocks = m_logicGameManager.Map[position.x, position.y];
foreach (var block in blocks)
{
if (!HasAttribute(block, AttributeCategory.Move) || !DirectionUtils.IsParallel(scanDirection, block.direction))
{
continue;
}
var impactDirection = 1;
var impactDisplacement = scanDisplacement;
if (block.direction != scanDirection)
{
impactDirection = 2;
impactDisplacement = Vector2Int.zero - scanDisplacement;
}
impactBlocks[block] = impactBlocks.GetOrDefault(block, 0) | impactDirection;
if (HasAttribute(block, AttributeCategory.Push))
{
for (var pushPosition = position + impactDisplacement; m_logicGameManager.InMap(pushPosition); pushPosition += impactDisplacement)
{
var pushBlocks = m_logicGameManager.Map[pushPosition.x, pushPosition.y];
var hasPush = false;
foreach (var pushBlock in pushBlocks)
{
if (HasAttribute(pushBlock, AttributeCategory.Push))
{
impactBlocks[pushBlock] = impactBlocks.GetOrDefault(pushBlock, 0) | impactDirection;
hasPush = true;
}
}
if (!hasPush)
{
break;
}
}
}
if (HasAttribute(block, AttributeCategory.Pull))
{
for (var pullPosition = position - impactDisplacement; m_logicGameManager.InMap(pullPosition); pullPosition -= impactDisplacement)
{
var pullBlocks = m_logicGameManager.Map[pullPosition.x, pullPosition.y];
var hasPull = false;
foreach (var pullBlock in pullBlocks)
{
if (HasAttribute(pullBlock, AttributeCategory.Pull))
{
impactBlocks[pullBlock] = impactBlocks.GetOrDefault(pullBlock, 0) | impactDirection;
hasPull = true;
}
}
if (!hasPull)
{
break;
}
}
}
}
}
for (var position = positiveEndPosition - scanDisplacement; position != negativeEndPosition; position -= scanDisplacement)
{
var blocks = m_logicGameManager.Map[position.x, position.y];
foreach (var block in blocks)
{
if (impactBlocks.GetOrDefault(block, 0) == 3)
{
impactBlocks[block] = 0;
}
}
}
HandlePreMove(impactBlocks, scanDisplacement, tickCommands);
{
var stopPosition = positiveEndPosition - scanDisplacement;
{
var blocks = m_logicGameManager.Map[stopPosition.x, stopPosition.y];
foreach (var block in blocks)
{
var impact = 0;
if (impactBlocks.TryGetValue(block, out impact))
{
impactBlocks[block] &= ~1;
}
}
}
}
{
var stopPosition = negativeEndPosition + scanDisplacement;
{
var blocks = m_logicGameManager.Map[stopPosition.x, stopPosition.y];
foreach (var block in blocks)
{
var impact = 0;
if (impactBlocks.TryGetValue(block, out impact))
{
impactBlocks[block] &= ~2;
}
}
}
}
for (var position = positiveEndPosition - scanDisplacement; position != negativeEndPosition + scanDisplacement; position -= scanDisplacement)
{
var hasStop = false;
{
var blocks = m_logicGameManager.Map[position.x, position.y];
foreach (var block in blocks)
{
if (HasAttribute(block, AttributeCategory.Stop) || HasAttribute(block, AttributeCategory.Pull) || HasAttribute(block, AttributeCategory.Push))
{
if (impactBlocks.GetOrDefault(block, 0) != 1)
{
hasStop = true;
break;
}
}
}
}
if (hasStop)
{
var stopPosition = position - scanDisplacement;
{
var blocks = m_logicGameManager.Map[stopPosition.x, stopPosition.y];
foreach (var block in blocks)
{
var impact = 0;
if (impactBlocks.TryGetValue(block, out impact))
{
impactBlocks[block] &= ~1;
}
}
}
}
}
for (var position = negativeEndPosition + scanDisplacement; position != positiveEndPosition - scanDisplacement; position += scanDisplacement)
{
var hasStop = false;
{
var blocks = m_logicGameManager.Map[position.x, position.y];
foreach (var block in blocks)
{
if (HasAttribute(block, AttributeCategory.Stop) || HasAttribute(block, AttributeCategory.Pull) || HasAttribute(block, AttributeCategory.Push))
{
if (impactBlocks.GetOrDefault(block, 0) != 2)
{
hasStop = true;
break;
}
}
}
}
if (hasStop)
{
var stopPosition = position + scanDisplacement;
{
var blocks = m_logicGameManager.Map[stopPosition.x, stopPosition.y];
foreach (var block in blocks)
{
var impact = 0;
if (impactBlocks.TryGetValue(block, out impact))
{
impactBlocks[block] &= ~2;
}
}
}
}
}
foreach (var impactBlockPair in impactBlocks)
{
var block = impactBlockPair.Key;
var impact = impactBlockPair.Value;
if (canBounce)
{
if (HasAttribute(block, AttributeCategory.Move) && impact == 0)
{
block.direction = DirectionUtils.GetOppositeDirection(block.direction);
}
}
else
{
if (impact == 1)
{
PerformMoveBlockCommand(block, scanDirection, 1, tickCommands);
}
else if (impact == 2)
{
PerformMoveBlockCommand(block, DirectionUtils.GetOppositeDirection(scanDirection), 1, tickCommands);
}
}
}
DictionaryPool <Block, int> .Release(impactBlocks);
}
/// <summary>
/// Runs distribution algorithm on input.
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="available">The amount you want to distribute</param>
/// <returns>The overflow</returns>
public static float ReqDistribute(List <DistributionInput> input, List <DistributionResult> output, float available)
{
List <TObject> tmp = ListPool <TObject> .Get();
List <TObject> objs = ListPool <TObject> .Get();
Dictionary <TObject, float> distributed = DictionaryPool <TObject, float> .Get();
Dictionary <TObject, float> requested = DictionaryPool <TObject, float> .Get();
float availablePrev = -available;
// Parse
foreach (var inp in input)
{
if (Mathf.Approximately(inp.requestedAmount, 0))
{
continue;
}
distributed.Add(inp.obj, 0);
requested.Add(inp.obj, inp.requestedAmount);
objs.Add(inp.obj);
}
int panic = 0;
while (available > 0 && !Mathf.Approximately(available, availablePrev) && requested.Count > 0)
{
availablePrev = available;
float perInput = available / (float)requested.Count;
foreach (var obj in objs)
{
float alreadyDistributed = distributed[obj];
float stillRequested = requested[obj];
float distributing = Mathf.Min(stillRequested, perInput);
distributed[obj] += distributing;
requested[obj] -= distributing;
available -= distributing;
if (Mathf.Approximately(requested[obj], 0))
{
tmp.Add(obj);
}
}
foreach (var obj in tmp)
{
objs.Remove(obj);
requested.Remove(obj);
}
tmp.Clear();
panic++;
if (panic > 1000)
{
Debug.LogError("Distribution alrogithm triggered panic exit!");
return(available);
}
}
// Write back
foreach (var kvp in distributed)
{
output.Add(new DistributionResult()
{
amount = kvp.Value,
obj = kvp.Key
});
}
DictionaryPool <TObject, float> .Return(distributed);
DictionaryPool <TObject, float> .Return(requested);
ListPool <TObject> .Return(tmp);
ListPool <TObject> .Return(objs);
return(available);
}
public void RegisterReplacementsForNames(params string[] origNames)
{
var needsTranslation = ListPool <string> .Get();
try
{
needsTranslation.Capacity = origNames.Length;
var fastReplacements = DictionaryPool <string, string> .Get();
try
{
foreach (var origString in origNames)
{
if (TranslationHelper.TryTranslateName(NameScope.DefaultNameScope, origString,
out var translatedString))
{
//fastReplacements[origString] = origString;
fastReplacements[translatedString] = translatedString;
}
else
{
needsTranslation.Add(origString);
}
}
if (fastReplacements.Count > 0)
{
RegisterReplacementStrings(fastReplacements);
}
}
finally
{
DictionaryPool <string, string> .Release(fastReplacements);
}
foreach (var toTranslate in needsTranslation)
{
void ResultHandler(ITranslationResult result)
{
var replacements = DictionaryPool <string, string> .Get();
try
{
if (!TranslationHelper.NameNeedsTranslation(toTranslate, NameScope.DefaultNameScope))
{
replacements[toTranslate] = toTranslate;
}
if (result.Succeeded)
{
replacements[result.TranslatedText] = result.TranslatedText;
}
RegisterReplacementStrings(replacements);
}
finally
{
DictionaryPool <string, string> .Release(replacements);
}
}
GeBoAPI.Instance.AutoTranslationHelper.TranslateAsync(toTranslate,
NameScope.DefaultNameScope.TranslationScope, ResultHandler);
}
}
finally
{
ListPool <string> .Release(needsTranslation);
}
}
public virtual void ValidateNode()
{
var isInError = false;
// all children nodes needs to be updated first
// so do that here
var slots = ListPool <MaterialSlot> .Get();
GetInputSlots(slots);
foreach (var inputSlot in slots)
{
inputSlot.hasError = false;
var edges = owner.GetEdges(inputSlot.slotReference);
foreach (var edge in edges)
{
var fromSocketRef = edge.outputSlot;
var outputNode = owner.GetNodeFromGuid(fromSocketRef.nodeGuid);
if (outputNode == null)
{
continue;
}
outputNode.ValidateNode();
if (outputNode.hasError)
{
isInError = true;
}
}
}
ListPool <MaterialSlot> .Release(slots);
var dynamicInputSlotsToCompare = DictionaryPool <DynamicVectorMaterialSlot, ConcreteSlotValueType> .Get();
var skippedDynamicSlots = ListPool <DynamicVectorMaterialSlot> .Get();
var dynamicMatrixInputSlotsToCompare = DictionaryPool <DynamicMatrixMaterialSlot, ConcreteSlotValueType> .Get();
var skippedDynamicMatrixSlots = ListPool <DynamicMatrixMaterialSlot> .Get();
// iterate the input slots
s_TempSlots.Clear();
GetInputSlots(s_TempSlots);
foreach (var inputSlot in s_TempSlots)
{
// if there is a connection
var edges = owner.GetEdges(inputSlot.slotReference).ToList();
if (!edges.Any())
{
if (inputSlot is DynamicVectorMaterialSlot)
{
skippedDynamicSlots.Add(inputSlot as DynamicVectorMaterialSlot);
}
if (inputSlot is DynamicMatrixMaterialSlot)
{
skippedDynamicMatrixSlots.Add(inputSlot as DynamicMatrixMaterialSlot);
}
continue;
}
// get the output details
var outputSlotRef = edges[0].outputSlot;
var outputNode = owner.GetNodeFromGuid(outputSlotRef.nodeGuid);
if (outputNode == null)
{
continue;
}
var outputSlot = outputNode.FindOutputSlot <MaterialSlot>(outputSlotRef.slotId);
if (outputSlot == null)
{
continue;
}
if (outputSlot.hasError)
{
inputSlot.hasError = true;
continue;
}
var outputConcreteType = outputSlot.concreteValueType;
// dynamic input... depends on output from other node.
// we need to compare ALL dynamic inputs to make sure they
// are compatable.
if (inputSlot is DynamicVectorMaterialSlot)
{
dynamicInputSlotsToCompare.Add((DynamicVectorMaterialSlot)inputSlot, outputConcreteType);
continue;
}
else if (inputSlot is DynamicMatrixMaterialSlot)
{
dynamicMatrixInputSlotsToCompare.Add((DynamicMatrixMaterialSlot)inputSlot, outputConcreteType);
continue;
}
// if we have a standard connection... just check the types work!
if (!ImplicitConversionExists(outputConcreteType, inputSlot.concreteValueType))
{
inputSlot.hasError = true;
}
}
// we can now figure out the dynamic slotType
// from here set all the
var dynamicType = ConvertDynamicInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
foreach (var dynamicKvP in dynamicInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicType);
}
foreach (var skippedSlot in skippedDynamicSlots)
{
skippedSlot.SetConcreteType(dynamicType);
}
// and now dynamic matrices
var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicMatrixInputSlotsToCompare.Values);
foreach (var dynamicKvP in dynamicMatrixInputSlotsToCompare)
{
dynamicKvP.Key.SetConcreteType(dynamicMatrixType);
}
foreach (var skippedSlot in skippedDynamicMatrixSlots)
{
skippedSlot.SetConcreteType(dynamicMatrixType);
}
s_TempSlots.Clear();
GetInputSlots(s_TempSlots);
var inputError = s_TempSlots.Any(x => x.hasError);
// configure the output slots now
// their slotType will either be the default output slotType
// or the above dynanic slotType for dynamic nodes
// or error if there is an input error
s_TempSlots.Clear();
GetOutputSlots(s_TempSlots);
foreach (var outputSlot in s_TempSlots)
{
outputSlot.hasError = false;
if (inputError)
{
outputSlot.hasError = true;
continue;
}
if (outputSlot is DynamicVectorMaterialSlot)
{
(outputSlot as DynamicVectorMaterialSlot).SetConcreteType(dynamicType);
continue;
}
else if (outputSlot is DynamicMatrixMaterialSlot)
{
(outputSlot as DynamicMatrixMaterialSlot).SetConcreteType(dynamicMatrixType);
continue;
}
}
isInError |= inputError;
s_TempSlots.Clear();
GetOutputSlots(s_TempSlots);
isInError |= s_TempSlots.Any(x => x.hasError);
isInError |= CalculateNodeHasError();
hasError = isInError;
if (!hasError)
{
++version;
}
ListPool <DynamicVectorMaterialSlot> .Release(skippedDynamicSlots);
DictionaryPool <DynamicVectorMaterialSlot, ConcreteSlotValueType> .Release(dynamicInputSlotsToCompare);
ListPool <DynamicMatrixMaterialSlot> .Release(skippedDynamicMatrixSlots);
DictionaryPool <DynamicMatrixMaterialSlot, ConcreteSlotValueType> .Release(dynamicMatrixInputSlotsToCompare);
}
private void HandleDirectionYou(Direction moveDirection, Vector2Int negativeEndPosition, Vector2Int positiveEndPosition, Stack <Command> tickCommands)
{
var displacement = DirectionUtils.DirectionToDisplacement(moveDirection);
var impactBlocks = DictionaryPool <Block, int> .Get();
for (var position = negativeEndPosition + displacement; position != positiveEndPosition; position += displacement)
{
var hasYou = false;
{
var blocks = m_logicGameManager.Map[position.x, position.y];
foreach (var block in blocks)
{
if (HasAttribute(block, AttributeCategory.You))
{
impactBlocks[block] = impactBlocks.GetOrDefault(block, 0) | 1;
hasYou = true;
}
}
}
if (hasYou)
{
for (var pullPosition = position - displacement; m_logicGameManager.InMap(pullPosition); pullPosition -= displacement)
{
var blocks = m_logicGameManager.Map[pullPosition.x, pullPosition.y];
var hasPull = false;
foreach (var block in blocks)
{
if (HasAttribute(block, AttributeCategory.Pull))
{
impactBlocks[block] = impactBlocks.GetOrDefault(block, 0) | 1;
hasPull = true;
}
}
if (!hasPull)
{
break;
}
}
for (var pushPosition = position + displacement; m_logicGameManager.InMap(pushPosition); pushPosition += displacement)
{
var blocks = m_logicGameManager.Map[pushPosition.x, pushPosition.y];
var hasPush = false;
foreach (var block in blocks)
{
if (HasAttribute(block, AttributeCategory.Push))
{
impactBlocks[block] = impactBlocks.GetOrDefault(block, 0) | 1;
hasPush = true;
}
}
if (!hasPush)
{
break;
}
}
}
}
HandlePreMove(impactBlocks, displacement, tickCommands);
{
var stopPosition = positiveEndPosition - displacement;
{
var blocks = m_logicGameManager.Map[stopPosition.x, stopPosition.y];
foreach (var block in blocks)
{
var impact = 0;
if (impactBlocks.TryGetValue(block, out impact))
{
impactBlocks[block] = 0;
}
}
}
}
for (var position = positiveEndPosition - displacement; position != negativeEndPosition + displacement; position -= displacement)
{
var hasStop = false;
{
var blocks = m_logicGameManager.Map[position.x, position.y];
foreach (var block in blocks)
{
if (HasAttribute(block, AttributeCategory.Stop) || HasAttribute(block, AttributeCategory.Pull) || HasAttribute(block, AttributeCategory.Push))
{
if (impactBlocks.GetOrDefault(block, 0) == 0)
{
hasStop = true;
break;
}
}
}
}
if (hasStop)
{
var stopPosition = position - displacement;
{
var blocks = m_logicGameManager.Map[stopPosition.x, stopPosition.y];
foreach (var block in blocks)
{
var impact = 0;
if (impactBlocks.TryGetValue(block, out impact))
{
impactBlocks[block] = 0;
}
}
}
}
}
foreach (var impactBlockPair in impactBlocks)
{
var block = impactBlockPair.Key;
var impact = impactBlockPair.Value;
if (impact == 1)
{
PerformMoveBlockCommand(block, moveDirection, 1, tickCommands);
}
}
DictionaryPool <Block, int> .Release(impactBlocks);
}
