public void SetCacheInstance(Type cacheContextType)
{
if (cacheContextType == null)
{
throw new ArgumentNullException("cacheContextType");
}
if (!typeof(CacheContext).IsAssignableFrom(cacheContextType))
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, "该类型 {0} 必须继承自抽象类CacheContext", cacheContextType),
"cacheContextType");
}
try
{
CacheContext = Activator.CreateInstance(cacheContextType) as CacheContext;
}
catch (Exception ex)
{
throw new InvalidOperationException(
String.Format(
CultureInfo.CurrentCulture,
"创建抽象类 CacheContext 的实例 {0} 失败",
cacheContextType),
ex);
}
}
protected BaseController(IDbConnection db, IMetricTracker metrics, ICacheClient cache)
{
Db = db;
Metrics = metrics;
Log = LogManager.GetLogger(GetType());
Cache = cache;
CacheContext = new CacheContext(Cache);
}
/// <summary>
/// 动态设置缓存对象的新实例
/// </summary>
/// <param name="cacheContext">缓存实例对象</param>
public void SetCacheInstance(CacheContext cacheContext)
{
//先释放现有的缓存组件
if (CacheContext != null)
{
CacheContext = null;
}
//初始化缓存组件新的实例
CacheContext = cacheContext;
}
public override void OnActionExecuting(ActionExecutingContext context)
{
var cacheProvider = new CacheContext();
IList <LoginRoleDto> mt = cacheProvider.GetCache <IList <LoginRoleDto> >("nav" + GetLoginUserId.ToString());
string url = Request.Path.Value.ToLower();
if (url.Split('/').Length == 2)
{
url = url + "/index";
}
if (string.IsNullOrEmpty(url.Split('/')[2]))
{
url = url + "index";
}
if (url.Split('/').Length > 3)
{
url = url.Split('/')[0] + "/" + url.Split('/')[1] + "/" + url.Split('/')[2];
}
var first = mt.YDBSFirst(s => s.modules.URL.ToLower().Equals(url));
ViewBag.CurrentNav = first == null ? null : first.modules.Id.ToString();
base.OnActionExecuting(context);
}
public void ScopesCanBeEnteredAndExited()
{
var scopeA = new CacheContext("a");
var scopeB = new CacheContext("b");
var scopeC = new CacheContext("c");
var scopeD = new CacheContext("d");
var sut = new CacheScopeManager();
sut.EnterScope(scopeA);
sut.EnterScope(scopeB);
sut.ExitScope();
sut.EnterScope(scopeC);
sut.ExitScope();
sut.ExitScope();
sut.EnterScope(scopeD);
sut.ExitScope();
}
private async Task SetCachedValueAsync(string cacheKey, string value, CacheContext context)
{
var bytes = Encoding.UTF8.GetBytes(value);
var options = new DistributedCacheEntryOptions
{
AbsoluteExpiration = context.ExpiresOn,
SlidingExpiration = context.ExpiresSliding,
AbsoluteExpirationRelativeToNow = context.ExpiresAfter
};
// Default duration is sliding expiration (permanent as long as it's used)
if (!options.AbsoluteExpiration.HasValue && !options.SlidingExpiration.HasValue && !options.AbsoluteExpirationRelativeToNow.HasValue)
{
options.SlidingExpiration = new TimeSpan(0, 1, 0);
}
await _dynamicCache.SetAsync(cacheKey, bytes, options);
// Lazy load to prevent cyclic dependency
var tagCache = _serviceProvider.GetRequiredService <ITagCache>();
await tagCache.TagAsync(cacheKey, context.Tags.ToArray());
}
public override object Execute(List <string> args)
{
foreach (var property in Definition.ShaderProperties)
{
RenderMethodTemplate template = null;
using (var cacheStream = CacheContext.OpenTagCacheRead())
template = CacheContext.Deserialize <RenderMethodTemplate>(cacheStream, property.Template);
for (var i = 0; i < template.VectorArguments.Count; i++)
{
Console.WriteLine("");
var argumentName = CacheContext.GetString(template.VectorArguments[i].Name);
var argumentValue = new RealQuaternion(property.Arguments[i].Values);
Console.WriteLine(string.Format("{0}:", argumentName));
if (argumentName.EndsWith("_map"))
{
Console.WriteLine(string.Format("\tX Scale: {0}", argumentValue.I));
Console.WriteLine(string.Format("\tY Scale: {0}", argumentValue.J));
Console.WriteLine(string.Format("\tX Offset: {0}", argumentValue.K));
Console.WriteLine(string.Format("\tY Offset: {0}", argumentValue.W));
}
else
{
Console.WriteLine(string.Format("\tX: {0}", argumentValue.I));
Console.WriteLine(string.Format("\tY: {0}", argumentValue.J));
Console.WriteLine(string.Format("\tZ: {0}", argumentValue.K));
Console.WriteLine(string.Format("\tW: {0}", argumentValue.W));
}
}
}
return(true);
}
public LancamentoViewModel(IContextProvider repositorio)
{
_context = repositorio.CacheContext;
Batidas = new ObservableCollection <Batida>();
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
Batidas.Add(new Batida {
Horario = new DateTime(2012, 1, 1, 08, 0, 0), NaturezaBatida = NaturezaBatida.Entrada
});
Batidas.Add(new Batida {
Horario = new DateTime(2012, 1, 1, 12, 0, 0), NaturezaBatida = NaturezaBatida.Saida
});
Batidas.Add(new Batida {
Horario = new DateTime(2012, 1, 1, 13, 0, 0), NaturezaBatida = NaturezaBatida.Entrada
});
Batidas.Add(new Batida {
Horario = new DateTime(2012, 1, 1, 18, 0, 0), NaturezaBatida = NaturezaBatida.Saida
});
}
else
{
// Code runs "for real"
_configuracao = _context.Configuracoes.FirstOrDefault();
AdicionarBatida = new RelayCommand(AddBatida);
RemoverBatida = new RelayCommand <Batida>(RemoveBatida);
Batidas.CollectionChanged += (sender, args) =>
{
RaisePropertyChanged("HorarioTrabalhado");
RaisePropertyChanged("Resumo");
};
}
}
public void GetFieldValue(object owner, object value = null, object definition = null)
{
if (value == null)
{
value = Field.GetValue(owner);
}
Owner = owner;
Loading = true;
if (value == null)
{
textBox.Text = "";
return;
}
var tag = (CachedTagInstance)value;
var tagName = tag.Name ?? $"0x{tag.Index:X4}";
textBox.Text = $"{tagName}.{CacheContext.GetString(tag.Group.Name)}";
Loading = false;
}
private void SyncRedisCache(DateTime date)
{
var siteDomains = DbContext.Domain.Select(p => p.SiteDomain).ToList();
foreach (var domain in siteDomains)
{
var redisKey = string.Format("visitor:loyalty:{0}:{1}", date.ToString("yyyyMMdd"), domain);
var redisBody = CacheContext.Get <List <VisitorLoyaltyByDayCacheItem> >(redisKey);
if (redisBody != null)
{
var lockDomain = domain;
var query = from p in DbContext.VisitorLoyalty
where p.SiteDomain == lockDomain && p.TotalDate == date
select p.Id;
var queryCount = query.Count();
if (queryCount > 0)
{
DbContext.VisitorLoyalty.Delete(p => p.SiteDomain == lockDomain && p.TotalDate == date);
}
foreach (var m in redisBody)
{
DbContext.VisitorLoyalty.Add(new VisitorLoyalty
{
SiteDomain = m.SiteDomain,
TotalDate = m.TotalDate,
FrequencyCount = m.FrequencyCount,
UniqueUser = m.UniqueUser,
PageView = m.PageView
});
}
DbContext.SaveChanges();
}
}
}
public void Test_OnFieldChange()
{
CacheInvalidator <int, string> cacheInvalidator;
ICache <int, string> cache;
long[] testFieldTypes;
const int numFieldTypes = 10;
Func <long, bool> fieldTypesToRemove;
cache = new DictionaryCache <int, string>();
for (int i = 0; i < numFieldTypes; i++)
{
cache.Add(i, i.ToString());
}
fieldTypesToRemove = e => e % 2 == 0; // All even numbered relationship types.
testFieldTypes = Enumerable.Range(0, numFieldTypes)
.Where(i => fieldTypesToRemove(i))
.Select(i => (long)i)
.ToArray();
cacheInvalidator = new CacheInvalidator <int, string>(cache, "a");
for (int i = 0; i < numFieldTypes; i++)
{
using (CacheContext cacheContext = new CacheContext())
{
cacheContext.FieldTypes.Add(i);
cacheInvalidator.AddInvalidations(cacheContext, i);
}
}
cacheInvalidator.OnFieldChange(testFieldTypes);
Assert.That(cache.Where(ce => fieldTypesToRemove(ce.Key)), Is.Empty);
}
public void Test_DetachedContext()
{
long testEntityRef;
long testRelationshipTypeRef;
long testFieldTypeRef;
testEntityRef = 1;
testRelationshipTypeRef = 2;
testFieldTypeRef = 3;
using (CacheContext outerCacheContext = new CacheContext())
{
using (CacheContext detachedCacheContext = new CacheContext(ContextType.Detached))
{
detachedCacheContext.Entities.Add(testEntityRef);
detachedCacheContext.RelationshipTypes.Add(testRelationshipTypeRef);
detachedCacheContext.FieldTypes.Add(testFieldTypeRef);
Assert.That(outerCacheContext, Has.Property("Entities").Count.EqualTo(0));
Assert.That(outerCacheContext, Has.Property("RelationshipTypes").Count.EqualTo(0));
Assert.That(outerCacheContext, Has.Property("FieldTypes").Count.EqualTo(0));
Assert.That(outerCacheContext, Has.Property("EntityInvalidatingRelationshipTypes").Count.EqualTo(0));
}
}
}
public override object Execute(List <string> args)
{
if (args.Count != 1)
{
return(false);
}
if (!CacheContext.TryGetTag(args[0], out var tag))
{
return(false);
}
using (var stream = CacheContext.OpenTagCacheReadWrite())
{
var tagName = tag.Name ?? "<unnamed>";
Console.Write($"Nulling {tagName}.{CacheContext.GetString(tag.Group.Name)}...");
CacheContext.TagCache.Index[tag.Index] = null;
CacheContext.TagCache.SetTagDataRaw(stream, tag, new byte[] { });
Console.WriteLine("done.");
}
return(true);
}
private string GetLabel(IList elements, int index)
{
if (index < 0 || index >= elements.Count)
{
return(null);
}
foreach (var info in TagStructure.GetTagFieldEnumerable(elements.GetType().GetGenericArguments()[0], CacheContext.Version))
{
if (info.Attribute == null || !info.Attribute.Flags.HasFlag(TagFieldFlags.Label))
{
continue;
}
var value = info.FieldInfo.GetValue(elements[index]);
if (info.FieldType == typeof(string))
{
return((string)value);
}
else if (info.FieldType == typeof(StringId))
{
return(CacheContext.GetString((StringId)value));
}
else if (info.FieldType.IsPrimitive && Tag.IsInGroup <Scenario>())
{
return(GetLabel((IList)typeof(Scenario).GetField(nameof(Scenario.ObjectNames)).GetValue(Owner), Convert.ToInt32(value)));
}
else
{
return(value.ToString());
}
}
return(null);
}
public override object Execute(List <string> args)
{
if (args.Count != 0)
{
return(false);
}
foreach (var property in Definition.ShaderProperties)
{
RenderMethodTemplate template = null;
using (var cacheStream = CacheContext.OpenTagCacheRead())
template = CacheContext.Deserialize <RenderMethodTemplate>(cacheStream, property.Template);
for (var i = 0; i < template.SamplerArguments.Count; i++)
{
var mapTemplate = template.SamplerArguments[i];
Console.WriteLine($"Bitmap {i} ({CacheContext.GetString(mapTemplate.Name)}): {property.ShaderMaps[i].Bitmap.Group.Tag} 0x{property.ShaderMaps[i].Bitmap.Index:X4}");
}
}
return(true);
}
private static void CacheMonitorTimer_Elapsed(object sender, ElapsedEventArgs e)
{
lock (s_cache)
{
foreach (string username in s_cache.Keys.ToList())
{
CacheContext cacheContext = s_cache[username];
if (DateTime.UtcNow.Subtract(cacheContext.LastAccessTime).TotalMinutes > s_userCacheTimeout)
{
s_cache.Remove(username);
}
else
{
cacheContext.Refresh();
}
}
}
lock (s_autoRefreshProviders)
{
for (int i = s_autoRefreshProviders.Count - 1; i >= 0; i--)
{
CacheContext cacheContext = s_autoRefreshProviders[i];
if (DateTime.UtcNow.Subtract(cacheContext.LastRefreshTime).TotalMinutes > s_userCacheTimeout)
{
if (!cacheContext.Refresh())
{
s_autoRefreshProviders[i] = s_autoRefreshProviders[s_autoRefreshProviders.Count - 1];
s_autoRefreshProviders.RemoveAt(s_autoRefreshProviders.Count - 1);
}
}
}
}
}
/// <summary>
/// Build and return the console navigation tree. This will be isolated by tenant and rule-set.
/// </summary>
/// <returns>
/// A <see cref="EntityData"/> containing the tree structure.
/// </returns>
/// <exception cref="InvalidOperationException">
/// The <see cref="ReadiNow.IO.RequestContext"/> is not set.
/// </exception>
public EntityData GetTree()
{
if (!ReadiNow.IO.RequestContext.IsSet)
{
throw new InvalidOperationException("Request context not set");
}
EntityData result;
var key = ReadiNow.IO.RequestContext.GetContext().Identity.Id;
_securedResultCache.TryGetOrAdd(key, out result, innerKey =>
{
// Add invalidation
using (CacheContext cacheContext = new CacheContext())
{
cacheContext.RelationshipTypes.Add(WellKnownAliases.CurrentTenant.AllowDisplay);
_cacheInvalidator.AddInvalidations(cacheContext, innerKey);
}
return(_innerRepository.GetTree());
});
return(result);
}
private CacheEntry CreateEntry(object k, Func<CacheContext, object> acquire)
{
var entry = new CacheEntry();
var context = new CacheContext(k, entry.AddCacheDependency);
CacheContext parentContext = null;
try
{
// Push context
parentContext = _accessor.Current;
_accessor.Current = context;
entry.Result = acquire(context);
}
finally
{
// Pop context
_accessor.Current = parentContext;
}
// Logger.TraceInformation("[{0}]: Cache miss for {1}", GetType().Name, k);
entry.CompactCacheDependencies();
return entry;
}
internal CacheContext ToCacheContext()
{
var cacheContext = new CacheContext(CacheId)
.AddContext(Contexts.ToArray())
.AddTag(Tags.ToArray());
if (ExpiresOn.HasValue)
{
cacheContext.WithExpiryOn(ExpiresOn.Value);
}
if (ExpiresAfter.HasValue)
{
cacheContext.WithExpiryAfter(ExpiresAfter.Value);
}
if (ExpiresSliding.HasValue)
{
cacheContext.WithExpirySliding(ExpiresSliding.Value);
}
return(cacheContext);
}
public bool GetCache(string token)
{
var cache = Get(token);
if (cache == null)
{
return(false);
}
if (cache.InvalidTime > DateTime.Now)
{
//延长
cache.InvalidTime = DateTime.Now.AddMinutes(5);
//设置缓存
CacheContext.Set(cache.Token, cache);
return(true);
}
//移除无效Session缓存
Remove(token);
return(false);
}
public MainnetRules(CacheContext cacheContext)
{
this._cacheContext = cacheContext;
this._highestTarget = UInt256.Parse("00000000FFFF0000000000000000000000000000000000000000000000000000", NumberStyles.HexNumber);
this._genesisBlock =
new Block
(
header: new BlockHeader
(
version: 1,
previousBlock: 0,
merkleRoot: UInt256.Parse("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b", NumberStyles.HexNumber),
time: 1231006505,
bits: 486604799,
nonce: 2083236893
),
transactions: ImmutableArray.Create
(
new Transaction
(
version: 1,
inputs: ImmutableArray.Create
(
new TxInput
(
previousTxOutputKey: new TxOutputKey
(
txHash: 0,
txOutputIndex: 0xFFFFFFFF
),
scriptSignature: ImmutableArray.Create <byte>
(
0x04, 0xFF, 0xFF, 0x00, 0x1D, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, 0x54, 0x69, 0x6D, 0x65,
0x73, 0x20, 0x30, 0x33, 0x2F, 0x4A, 0x61, 0x6E, 0x2F, 0x32, 0x30, 0x30, 0x39, 0x20, 0x43, 0x68,
0x61, 0x6E, 0x63, 0x65, 0x6C, 0x6C, 0x6F, 0x72, 0x20, 0x6F, 0x6E, 0x20, 0x62, 0x72, 0x69, 0x6E,
0x6B, 0x20, 0x6F, 0x66, 0x20, 0x73, 0x65, 0x63, 0x6F, 0x6E, 0x64, 0x20, 0x62, 0x61, 0x69, 0x6C,
0x6F, 0x75, 0x74, 0x20, 0x66, 0x6F, 0x72, 0x20, 0x62, 0x61, 0x6E, 0x6B, 0x73
),
sequence: 0xFFFFFFFF
)
),
outputs: ImmutableArray.Create
(
new TxOutput
(
value: 50 * SATOSHI_PER_BTC,
scriptPublicKey: ImmutableArray.Create <byte>
(
0x41, 0x04, 0x67, 0x8A, 0xFD, 0xB0, 0xFE, 0x55, 0x48, 0x27, 0x19, 0x67, 0xF1, 0xA6, 0x71, 0x30,
0xB7, 0x10, 0x5C, 0xD6, 0xA8, 0x28, 0xE0, 0x39, 0x09, 0xA6, 0x79, 0x62, 0xE0, 0xEA, 0x1F, 0x61,
0xDE, 0xB6, 0x49, 0xF6, 0xBC, 0x3F, 0x4C, 0xEF, 0x38, 0xC4, 0xF3, 0x55, 0x04, 0xE5, 0x1E, 0xC1,
0x12, 0xDE, 0x5C, 0x38, 0x4D, 0xF7, 0xBA, 0x0B, 0x8D, 0x57, 0x8A, 0x4C, 0x70, 0x2B, 0x6B, 0xF1,
0x1D, 0x5F, 0xAC
)
)
),
lockTime: 0
)
)
);
this._genesisChainedBlock =
new ChainedBlock
(
blockHash: this._genesisBlock.Hash,
previousBlockHash: this._genesisBlock.Header.PreviousBlock,
height: 0,
totalWork: this._genesisBlock.Header.CalculateWork()
);
this._genesisBlockchain =
new Data.Blockchain
(
blockList: ImmutableList.Create(this._genesisChainedBlock),
blockListHashes: ImmutableHashSet.Create(this._genesisBlock.Hash),
utxo: ImmutableDictionary.Create <UInt256, UnspentTx>() // genesis block coinbase is not included in utxo, it is unspendable
);
}
public ApplicationCache(CacheContext cacheContext, CacheHelper cacheHelper, ILogger logger)
{
_logger = logger;
_cacheContext = cacheContext;
_cache = cacheHelper.GetCache();
}
public void Render()
{
var variantName = Object.DefaultModelVariant != StringId.Invalid ?
CacheContext.GetString(Object.DefaultModelVariant) :
"default";
var modelVariant = Model.Variants.FirstOrDefault(v => (CacheContext.GetString(v.Name) ?? v.Name.ToString()) == variantName);
if (modelVariant == null && Model.Variants.Count > 0)
{
modelVariant = Model.Variants.First();
}
UpdateTransform();
Device.Transform.World = World;
foreach (var region in modelVariant.Regions)
{
if (region.RenderModelRegionIndex >= RenderModel.Regions.Count)
{
continue;
}
var renderModelRegion = RenderModel.Regions[region.RenderModelRegionIndex];
if (region.Permutations.Count == 0)
{
continue;
}
var permutation = region.Permutations[0];
if (permutation.RenderModelPermutationIndex < 0 || permutation.RenderModelPermutationIndex >= renderModelRegion.Permutations.Count)
{
continue;
}
var renderModelPermutation = renderModelRegion.Permutations[permutation.RenderModelPermutationIndex];
var meshIndex = renderModelPermutation.MeshIndex;
var meshCount = renderModelPermutation.MeshCount;
var regionName = CacheContext.GetString(region.Name) ?? region.Name.ToString();
var permutationName = CacheContext.GetString(permutation.Name) ?? permutation.Name.ToString();
for (var currentMeshIndex = 0; currentMeshIndex < meshCount; currentMeshIndex++)
{
var mesh = RenderModel.Geometry.Meshes[meshIndex + currentMeshIndex];
var renderVertex = VertexDefinition.Get(mesh.Type);
var streamTypes = renderVertex.GetStreamTypes();
var streamIndex = streamTypes.First().Key;
var primitiveType = D3DPrimitiveType.TriangleList;
switch (mesh.IndexBufferType)
{
case TagPrimitiveType.PointList:
primitiveType = D3DPrimitiveType.PointList;
break;
case TagPrimitiveType.LineList:
primitiveType = D3DPrimitiveType.LineList;
break;
case TagPrimitiveType.LineStrip:
primitiveType = D3DPrimitiveType.LineStrip;
break;
case TagPrimitiveType.TriangleList:
primitiveType = D3DPrimitiveType.TriangleList;
break;
case TagPrimitiveType.TriangleFan:
primitiveType = D3DPrimitiveType.TriangleFan;
break;
case TagPrimitiveType.TriangleStrip:
primitiveType = D3DPrimitiveType.TriangleStrip;
break;
}
Device.VertexDeclaration = renderVertex.GetDeclaration(Device);
Device.SetStreamSource(streamTypes.First().Key, VertexBuffers[mesh.VertexBufferIndices[streamIndex]], 0);
Device.Indices = IndexBuffers[mesh.IndexBufferIndices.Where(index => index != ushort.MaxValue).First()];
foreach (var part in mesh.Parts)
{
if (part.MaterialIndex != -1)
{
var material = Materials[part.MaterialIndex];
Device.RenderState.AlphaBlendEnable = (part.TypeNew == TagTool.Geometry.Mesh.Part.PartTypeNew.Transparent);
foreach (var entry in material.Textures)
{
var name = entry.Key;
if (name.StartsWith("diffuse_map") || name.StartsWith("base_map") || name == "foam_texture")
{
Device.SetTexture(0, entry.Value.Texture);
break;
}
}
Device.TextureState[0].ColorOperation = TextureOperation.Modulate;
Device.TextureState[0].ColorArgument1 = TextureArgument.TextureColor;
Device.TextureState[0].ColorArgument2 = TextureArgument.Current;
Device.RenderState.FillMode = FillMode.Solid;
}
for (var currentSubPartIndex = 0; currentSubPartIndex < part.SubPartCount; currentSubPartIndex++)
{
var subPart = mesh.SubParts[part.FirstSubPartIndex + currentSubPartIndex];
Device.DrawIndexedPrimitives(primitiveType, 0, 0, subPart.VertexCount, subPart.FirstIndex, subPart.IndexCount - (primitiveType == D3DPrimitiveType.TriangleStrip ? 2 : 0));
}
}
}
}
}
private Sound ConvertSound(Stream cacheStream, Dictionary <ResourceLocation, Stream> resourceStreams, Sound sound, string blamTag_Name)
{
if (BlamSoundGestalt == null)
{
BlamSoundGestalt = PortingContextFactory.LoadSoundGestalt(CacheContext, ref BlamCache);
}
if (!File.Exists(@"Tools\ffmpeg.exe") || !File.Exists(@"Tools\towav.exe"))
{
Console.WriteLine("Failed to locate sound conversion tools, please install ffmpeg and towav in the Tools folder");
return(null);
}
//
// Convert Sound Tag Data
//
var platformCodec = BlamSoundGestalt.PlatformCodecs[sound.SoundReference.PlatformCodecIndex];
var playbackParameters = BlamSoundGestalt.PlaybackParameters[sound.SoundReference.PlaybackParameterIndex];
var scale = BlamSoundGestalt.Scales[sound.SoundReference.ScaleIndex];
var promotion = sound.SoundReference.PromotionIndex != -1 ? BlamSoundGestalt.Promotions[sound.SoundReference.PromotionIndex] : new Promotion();
var customPlayBack = sound.SoundReference.CustomPlaybackIndex != -1 ? new List <CustomPlayback> {
BlamSoundGestalt.CustomPlaybacks[sound.SoundReference.CustomPlaybackIndex]
} : new List <CustomPlayback>();
var loop = sound.Flags.HasFlag(Sound.FlagsValue.LoopingSound);
sound.PlaybackParameters = playbackParameters;
sound.Scale = scale;
sound.PlatformCodec = platformCodec.DeepClone();
sound.Promotion = promotion;
sound.CustomPlayBacks = customPlayBack;
//
// Tag fixes
//
sound.SampleRate = platformCodec.SampleRate;
sound.ImportType = ImportType.SingleLayer;
// helps looping sound? there is another value, 10 for Unknown2 but I don't know when to activate it.
if (sound.SoundReference.PitchRangeCount > 1)
{
sound.ImportType = ImportType.MultiLayer;
}
sound.PlatformCodec.LoadMode = 0;
//
// Process all the pitch ranges
//
var xmaFileSize = BlamSoundGestalt.GetFileSize(sound.SoundReference.PitchRangeIndex, sound.SoundReference.PitchRangeCount);
if (xmaFileSize < 0)
{
return(null);
}
var xmaData = BlamCache.GetSoundRaw(sound.SoundReference.ZoneAssetHandle, xmaFileSize);
if (xmaData == null)
{
return(null);
}
sound.PitchRanges = new List <PitchRange>(sound.SoundReference.PitchRangeCount);
var soundDataAggregate = new byte[0].AsEnumerable();
var currentSoundDataOffset = 0;
var totalSampleCount = (uint)0;
for (int pitchRangeIndex = sound.SoundReference.PitchRangeIndex; pitchRangeIndex < sound.SoundReference.PitchRangeIndex + sound.SoundReference.PitchRangeCount; pitchRangeIndex++)
{
totalSampleCount += BlamSoundGestalt.GetSamplesPerPitchRange(pitchRangeIndex);
//
// Convert Blam pitch range to ElDorado format
//
var pitchRange = BlamSoundGestalt.PitchRanges[pitchRangeIndex];
pitchRange.ImportName = ConvertStringId(BlamSoundGestalt.ImportNames[pitchRange.ImportNameIndex].Name);
pitchRange.PitchRangeParameters = BlamSoundGestalt.PitchRangeParameters[pitchRange.PitchRangeParametersIndex];
pitchRange.Unknown1 = 0;
pitchRange.Unknown2 = 0;
pitchRange.Unknown3 = 0;
pitchRange.Unknown4 = 0;
pitchRange.Unknown5 = -1;
pitchRange.Unknown6 = -1;
//I suspect this unknown7 to be a flag to tell if there is a Unknownblock in extrainfo. (See a sound in udlg for example)
pitchRange.Unknown7 = 0;
pitchRange.PermutationCount = (byte)BlamSoundGestalt.GetPermutationCount(pitchRangeIndex);
pitchRange.Unknown8 = -1;
// Add pitch range to ED sound
sound.PitchRanges.Add(pitchRange);
var newPitchRangeIndex = pitchRangeIndex - sound.SoundReference.PitchRangeIndex;
sound.PitchRanges[newPitchRangeIndex].Permutations = new List <Permutation>();
//
// Determine the audio channel count
//
var channelCount = Encoding.GetChannelCount(sound.PlatformCodec.Encoding);
//
// Set compression format
//
sound.PlatformCodec.Compression = Compression.MP3;
//
// Convert Blam permutations to ElDorado format
//
var useCache = Sounds.UseAudioCacheCommand.AudioCacheDirectory != null;
var basePermutationCacheName = Path.Combine(
useCache ? Sounds.UseAudioCacheCommand.AudioCacheDirectory.FullName : TempDirectory.FullName,
GetTagFileFriendlyName(blamTag_Name));
var permutationCount = BlamSoundGestalt.GetPermutationCount(pitchRangeIndex);
var permutationOrder = BlamSoundGestalt.GetPermutationOrder(pitchRangeIndex);
var relativePitchRangeIndex = pitchRangeIndex - sound.SoundReference.PitchRangeIndex;
for (int i = 0; i < permutationCount; i++)
{
var permutationIndex = pitchRange.FirstPermutationIndex + i;
var permutationSize = BlamSoundGestalt.GetPermutationSize(permutationIndex);
var permutationOffset = BlamSoundGestalt.GetPermutationOffset(permutationIndex);
var permutation = BlamSoundGestalt.GetPermutation(permutationIndex).DeepClone();
permutation.ImportName = ConvertStringId(BlamSoundGestalt.ImportNames[permutation.ImportNameIndex].Name);
permutation.SkipFraction = new Bounds <float>(0.0f, permutation.Gain);
permutation.PermutationChunks = new List <PermutationChunk>();
permutation.PermutationNumber = (uint)permutationOrder[i];
permutation.IsNotFirstPermutation = (uint)(permutation.PermutationNumber == 0 ? 0 : 1);
string permutationName = $"{basePermutationCacheName}_{relativePitchRangeIndex}_{i}";
string extension = "mp3";
var cacheFileName = $"{permutationName}.{extension}";
bool exists = File.Exists(cacheFileName);
byte[] permutationData = null;
if (!exists || !useCache)
{
BlamSound blamSound = SoundConverter.ConvertGen3Sound(BlamCache, BlamSoundGestalt, sound, relativePitchRangeIndex, i, xmaData);
permutationData = blamSound.Data;
if (useCache)
{
using (EndianWriter output = new EndianWriter(new FileStream(cacheFileName, FileMode.Create, FileAccess.Write, FileShare.None), EndianFormat.BigEndian))
{
output.WriteBlock(blamSound.Data);
}
}
}
else
{
permutationData = File.ReadAllBytes(cacheFileName);
}
permutation.PermutationChunks.Add(new PermutationChunk(currentSoundDataOffset, permutationData.Length));
currentSoundDataOffset += permutationData.Length;
pitchRange.Permutations.Add(permutation);
soundDataAggregate = soundDataAggregate.Concat(permutationData);
}
}
sound.Promotion.LongestPermutationDuration = (uint)sound.SoundReference.MaximumPlayTime;
sound.Promotion.TotalSampleSize = totalSampleCount;
//
// Convert Blam extra info to ElDorado format
//
var extraInfo = new ExtraInfo()
{
LanguagePermutations = new List <ExtraInfo.LanguagePermutation>(),
EncodedPermutationSections = new List <ExtraInfo.EncodedPermutationSection>()
};
for (int u = 0; u < sound.SoundReference.PitchRangeCount; u++)
{
var pitchRange = BlamSoundGestalt.PitchRanges[sound.SoundReference.PitchRangeIndex + u];
for (int i = 0; i < pitchRange.PermutationCount; i++)
{
var permutation = BlamSoundGestalt.GetPermutation(pitchRange.FirstPermutationIndex + i);
var permutationChunk = BlamSoundGestalt.GetPermutationChunk(permutation.FirstPermutationChunkIndex);
extraInfo.LanguagePermutations.Add(new ExtraInfo.LanguagePermutation
{
RawInfo = new List <ExtraInfo.LanguagePermutation.RawInfoBlock>
{
new ExtraInfo.LanguagePermutation.RawInfoBlock
{
SkipFractionName = StringId.Invalid,
UnknownList = new List <ExtraInfo.LanguagePermutation.RawInfoBlock.Unknown>
{
new ExtraInfo.LanguagePermutation.RawInfoBlock.Unknown
{
Unknown1 = permutationChunk.UnknownA,
Unknown2 = permutationChunk.UnknownSize,
Unknown3 = 0,
Unknown4 = permutation.SampleSize,
Unknown5 = 0,
Unknown6 = permutationChunk.EncodedSize & 0xFFFF
}
},
Compression = 8,
ResourceSampleSize = pitchRange.Permutations[i].SampleSize,
ResourceSampleOffset = (uint)pitchRange.Permutations[i].PermutationChunks[0].Offset,
SampleCount = (uint)pitchRange.Permutations[i].PermutationChunks[0].EncodedSize & 0x3FFFFFF,
//SampleCount = (uint)Math.Floor(pitchRange.Permutations[i].SampleSize * 128000.0 / (8 * sound.SampleRate.GetSampleRateHz())),
Unknown24 = 480
}
}
});
}
}
if (sound.SoundReference.ExtraInfoIndex != -1)
{
foreach (var section in BlamSoundGestalt.ExtraInfo[sound.SoundReference.ExtraInfoIndex].EncodedPermutationSections)
{
var newSection = section.DeepClone();
foreach (var info in newSection.SoundDialogueInfo)
{
for (var i = ((info.MouthDataLength % 2) == 0 ? 0 : 1); (i + 1) < info.MouthDataLength; i += 2)
{
Array.Reverse(newSection.EncodedData, (int)(info.MouthDataOffset + i), 2);
}
for (var i = ((info.LipsyncDataLength % 2) == 0 ? 0 : 1); (i + 1) < info.LipsyncDataLength; i += 2)
{
Array.Reverse(newSection.EncodedData, (int)(info.LipsyncDataOffset + i), 2);
}
}
extraInfo.EncodedPermutationSections.Add(newSection);
}
}
sound.ExtraInfo = new List <ExtraInfo> {
extraInfo
};
//
// Convert Blam languages to ElDorado format
//
if (sound.SoundReference.LanguageIndex != -1)
{
sound.Languages = new List <LanguageBlock>();
foreach (var language in BlamSoundGestalt.Languages)
{
sound.Languages.Add(new LanguageBlock
{
Language = language.Language,
PermutationDurations = new List <LanguageBlock.PermutationDurationBlock>(),
PitchRangeDurations = new List <LanguageBlock.PitchRangeDurationBlock>(),
});
//Add all the Pitch Range Duration block (pitch range count dependent)
var curLanguage = sound.Languages.Last();
for (int i = 0; i < sound.SoundReference.PitchRangeCount; i++)
{
curLanguage.PitchRangeDurations.Add(language.PitchRangeDurations[sound.SoundReference.LanguageIndex + i]);
}
//Add all the Permutation Duration Block and adjust offsets
for (int i = 0; i < curLanguage.PitchRangeDurations.Count; i++)
{
var curPRD = curLanguage.PitchRangeDurations[i];
//Get current block count for new index
short newPermutationIndex = (short)curLanguage.PermutationDurations.Count();
for (int j = curPRD.PermutationStartIndex; j < curPRD.PermutationStartIndex + curPRD.PermutationCount; j++)
{
curLanguage.PermutationDurations.Add(language.PermutationDurations[j]);
}
//apply new index
curPRD.PermutationStartIndex = newPermutationIndex;
}
}
}
//
// Prepare resource
//
sound.Unused = new byte[] { 0, 0, 0, 0 };
sound.Unknown12 = 0;
sound.Resource = new PageableResource
{
Page = new RawPage
{
Index = -1,
},
Resource = new TagResourceGen3
{
ResourceType = TagResourceTypeGen3.Sound,
DefinitionData = new byte[20],
DefinitionAddress = new CacheResourceAddress(CacheResourceAddressType.Definition, 536870912),
ResourceFixups = new List <TagResourceGen3.ResourceFixup>(),
ResourceDefinitionFixups = new List <TagResourceGen3.ResourceDefinitionFixup>(),
Unknown2 = 1
}
};
var data = soundDataAggregate.ToArray();
var resourceContext = new ResourceSerializationContext(CacheContext, sound.Resource);
CacheContext.Serializer.Serialize(resourceContext,
new SoundResourceDefinition
{
Data = new TagData(data.Length, new CacheResourceAddress(CacheResourceAddressType.Resource, 0))
});
var definitionFixup = new TagResourceGen3.ResourceFixup()
{
BlockOffset = 12,
Address = new CacheResourceAddress(CacheResourceAddressType.Resource, 1073741824)
};
sound.Resource.Resource.ResourceFixups.Add(definitionFixup);
sound.Resource.ChangeLocation(ResourceLocation.Audio);
var resource = sound.Resource;
if (resource == null)
{
throw new ArgumentNullException("resource");
}
var cache = CacheContext.GetResourceCache(ResourceLocation.Audio);
if (!resourceStreams.ContainsKey(ResourceLocation.Audio))
{
resourceStreams[ResourceLocation.Audio] = FlagIsSet(PortingFlags.Memory) ?
new MemoryStream() :
(Stream)CacheContext.OpenResourceCacheReadWrite(ResourceLocation.Audio);
if (FlagIsSet(PortingFlags.Memory))
{
using (var resourceStream = CacheContext.OpenResourceCacheRead(ResourceLocation.Audio))
resourceStream.CopyTo(resourceStreams[ResourceLocation.Audio]);
}
}
resource.Page.Index = cache.Add(resourceStreams[ResourceLocation.Audio], data, out uint compressedSize);
resource.Page.CompressedBlockSize = compressedSize;
resource.Page.UncompressedBlockSize = (uint)data.Length;
resource.DisableChecksum();
for (int i = 0; i < 4; i++)
{
sound.Resource.Resource.DefinitionData[i] = (byte)(sound.Resource.Page.UncompressedBlockSize >> (i * 8));
}
return(sound);
}
public static async ValueTask <Completion> WriteToAsync(List <FilterArgument> arguments, IReadOnlyList <Statement> statements, TextWriter writer, TextEncoder encoder, TemplateContext context)
{
var services = ((LiquidTemplateContext)context).Services;
var dynamicCache = services.GetService <IDynamicCacheService>();
var cacheScopeManager = services.GetService <ICacheScopeManager>();
var loggerFactory = services.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger <CacheTag>();
var cacheOptions = services.GetRequiredService <IOptions <CacheOptions> >().Value;
if (dynamicCache == null || cacheScopeManager == null)
{
logger.LogInformation(@"Liquid cache block entered without an available IDynamicCacheService or ICacheScopeManager.
The contents of the cache block will not be cached.
To enable caching, make sure that a feature that contains an implementation of IDynamicCacheService and ICacheScopeManager is enabled (for example, 'Dynamic Cache').");
if (statements != null && statements.Count > 0)
{
var completion = await statements.RenderStatementsAsync(writer, encoder, context);
if (completion != Completion.Normal)
{
return(completion);
}
}
return(Completion.Normal);
}
var filterArguments = new FilterArguments();
foreach (var argument in arguments)
{
filterArguments.Add(argument.Name, await argument.Expression.EvaluateAsync(context));
}
var cacheKey = filterArguments.At(0).ToStringValue();
var contexts = filterArguments["vary_by"].ToStringValue();
var tags = filterArguments["dependencies"].ToStringValue();
var durationString = filterArguments["expires_after"].ToStringValue();
var slidingDurationString = filterArguments["expires_sliding"].ToStringValue();
var cacheContext = new CacheContext(cacheKey)
.AddContext(contexts.Split(SplitChars, StringSplitOptions.RemoveEmptyEntries))
.AddTag(tags.Split(SplitChars, StringSplitOptions.RemoveEmptyEntries));
if (TimeSpan.TryParse(durationString, out var duration))
{
cacheContext.WithExpiryAfter(duration);
}
if (TimeSpan.TryParse(slidingDurationString, out var slidingDuration))
{
cacheContext.WithExpirySliding(slidingDuration);
}
var cacheResult = await dynamicCache.GetCachedValueAsync(cacheContext);
if (cacheResult != null)
{
await writer.WriteAsync(cacheResult);
return(Completion.Normal);
}
cacheScopeManager.EnterScope(cacheContext);
var content = "";
try
{
if (statements != null && statements.Count > 0)
{
using var sb = StringBuilderPool.GetInstance();
using (var render = new StringWriter(sb.Builder))
{
foreach (var statement in statements)
{
await statement.WriteToAsync(render, encoder, context);
}
await render.FlushAsync();
}
content = sb.Builder.ToString();
}
}
finally
{
cacheScopeManager.ExitScope();
}
if (cacheOptions.DebugMode)
{
// No need to optimize this code as it will be used for debugging purpose.
var debugContent = new StringWriter();
debugContent.WriteLine();
debugContent.WriteLine($"<!-- CACHE BLOCK: {cacheContext.CacheId} ({Guid.NewGuid()})");
debugContent.WriteLine($" VARY BY: {String.Join(", ", cacheContext.Contexts)}");
debugContent.WriteLine($" DEPENDENCIES: {String.Join(", ", cacheContext.Tags)}");
debugContent.WriteLine($" EXPIRES ON: {cacheContext.ExpiresOn}");
debugContent.WriteLine($" EXPIRES AFTER: {cacheContext.ExpiresAfter}");
debugContent.WriteLine($" EXPIRES SLIDING: {cacheContext.ExpiresSliding}");
debugContent.WriteLine("-->");
debugContent.WriteLine(content);
debugContent.WriteLine();
debugContent.WriteLine($"<!-- END CACHE BLOCK: {cacheContext.CacheId} -->");
content = debugContent.ToString();
}
await dynamicCache.SetCachedValueAsync(cacheContext, content);
await writer.WriteAsync(content);
return(Completion.Normal);
}
/// <summary>
/// Runs the report.
/// </summary>
/// <param name="report">The report.</param>
/// <param name="reportSettings">The settings.</param>
/// <param name="suppressPreload">Pass true if the report has already been preloaded.</param>
/// <returns>ReportResult.</returns>
/// <exception cref="System.ArgumentException">@The report identifier resource is not a report.;reportId</exception>
public ReportCompletionData PrepareReport(Model.Report report, ReportSettings reportSettings, bool suppressPreload = false)
{
if (report == null)
{
throw new ArgumentNullException("report");
}
if (reportSettings == null)
{
reportSettings = new ReportSettings( );
}
StructuredQuery structuredQuery;
PreparedQuery preparedReport;
PreparedQuery preparedRollup;
using (EDC.ReadiNow.Diagnostics.Profiler.Measure("Prepare report run"))
using (MessageContext messageContext = new MessageContext("Reports"))
using (new SecurityBypassContext( ))
{
// Get the structured query
structuredQuery = GetStructuredQuery(report, reportSettings, suppressPreload);
// Handle metadata-only request
if (reportSettings.RequireSchemaMetadata)
{
ReportResult reportResult = new ReportResult(report, structuredQuery, null, null, null, reportSettings);
return(new ReportCompletionData(reportResult));
}
// Prepare query settings
preparedReport = PrepareReportRun(structuredQuery, reportSettings);
preparedReport.QuerySettings.Hint = "Rpt-" + report.Id.ToString( );
// Handle rollups
preparedRollup = PrepareReportRollupRun(report, preparedReport.StructuredQuery, reportSettings, preparedReport.QuerySettings);
}
Func <ReportResult> resultCallback = () =>
{
ReportResult reportResult = null;
QueryResult queryResult = null;
QueryResult rollupResult = null;
using (new SecurityBypassContext( ))
{
// Execute the query
queryResult = QueryRunner.ExecuteQuery(preparedReport.StructuredQuery, preparedReport.QuerySettings);
// Execute the rollup query
if (preparedRollup.StructuredQuery != null)
{
rollupResult = QueryRunner.ExecuteQuery(preparedRollup.StructuredQuery, preparedRollup.QuerySettings);
}
// Package up the result.
reportResult = new ReportResult(report,
preparedReport.StructuredQuery, queryResult,
preparedRollup.ClientAggregate, rollupResult,
reportSettings);
}
return(reportResult);
};
// Create cache key (null indicates report is not cacheable)
IQueryRunnerCacheKey reportCacheKey = null;
IQueryRunnerCacheKey rollupCacheKey = null;
ReportResultCacheKey reportResultCacheKey = null;
reportCacheKey = QueryRunnerCacheKeyProvider.CreateCacheKey(preparedReport.StructuredQuery, preparedReport.QuerySettings);
if (reportCacheKey != null)
{
if (preparedRollup.StructuredQuery != null)
{
rollupCacheKey = QueryRunnerCacheKeyProvider.CreateCacheKey(preparedRollup.StructuredQuery, preparedRollup.QuerySettings);
}
reportResultCacheKey = new ReportResultCacheKey(reportSettings, reportCacheKey, rollupCacheKey);
}
// Create completion result
ReportCompletionData completionData = new ReportCompletionData( );
completionData.ResultCallback = resultCallback;
completionData.ResultCacheKey = reportResultCacheKey;
completionData.CacheContextDuringPreparation = CacheContext.GetContext( );
return(completionData);
}
public override object Execute(List <string> args)
{
if (args.Count < 1 || args.Count > 2)
{
return(false);
}
if (args.Count == 2 && (args[0].ToLower() != "raw"))
{
return(false);
}
var file = "";
if (args.Count == 1)
{
file = args[0];
}
else
{
file = args[1];
}
var resourceContext = new ResourceSerializationContext(CacheContext, Geometry.Resource);
var definition = CacheContext.Deserializer.Deserialize <RenderGeometryApiResourceDefinition>(resourceContext);
if (args.Count == 2)
{
using (var edResourceStream = new MemoryStream())
using (var edResourceReader = new EndianReader(edResourceStream, EndianFormat.LittleEndian))
{
var directory = args[1];
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
var dataOutDir = directory;
for (var i = 0; i < definition.VertexBuffers.Count; i++)
{
edResourceStream.Position = definition.VertexBuffers[i].Definition.Data.Address.Offset;
var vertexBuffer = definition.VertexBuffers[i].Definition;
dataOutDir = Path.Combine(directory, $"{i}_{vertexBuffer.Format}_{vertexBuffer.Count}");
using (EndianWriter output = new EndianWriter(File.OpenWrite(dataOutDir), EndianFormat.LittleEndian))
{
byte[] data = edResourceReader.ReadBytes((int)vertexBuffer.Data.Size);
output.WriteBlock(data);
}
}
}
}
else
{
//
// Convert Blam data to ElDorado data
//
using (var fileStream = File.Create(file))
using (var fileWriter = new StreamWriter(fileStream))
{
using (var edResourceStream = new MemoryStream())
using (var edResourceReader = new EndianReader(edResourceStream, EndianFormat.LittleEndian))
{
//
// Convert Blam vertex buffers
//
Console.Write("Converting vertex buffers...");
CacheContext.ExtractResource(Geometry.Resource, edResourceStream);
for (var i = 0; i < definition.VertexBuffers.Count; i++)
{
edResourceStream.Position = definition.VertexBuffers[i].Definition.Data.Address.Offset;
var vertexBuffer = definition.VertexBuffers[i].Definition;
//fileWriter.WriteLine($"Offset = {vertexBuffer.Data.Address.Offset.ToString("X8")} Count = {vertexBuffer.Count} Size = {vertexBuffer.VertexSize}, Format = {vertexBuffer.Format.ToString()}");
//fileWriter.WriteLine(Environment.NewLine);
//fileWriter.WriteLine($"Vertex buffer index: {i}");
switch (vertexBuffer.Format)
{
case VertexBufferFormat.TinyPosition:
for (var j = 0; j < vertexBuffer.Count; j++)
{
fileWriter.WriteLine($"Position = ({edResourceReader.ReadUInt16().ToString("X4")},{edResourceReader.ReadUInt16().ToString("X4")},{edResourceReader.ReadUInt16().ToString("X4")},{edResourceReader.ReadUInt16().ToString("X4")})");
fileWriter.WriteLine($"Normal = ({edResourceReader.ReadByte().ToString("X2")},{edResourceReader.ReadByte().ToString("X2")},{edResourceReader.ReadByte().ToString("X2")},{edResourceReader.ReadByte().ToString("X2")})");
fileWriter.WriteLine($"Color = {edResourceReader.ReadUInt32().ToString("X8")}");
}
break;
case VertexBufferFormat.StaticPerVertex:
for (var j = 0; j < vertexBuffer.Count; j++)
{
fileWriter.WriteLine($"{vertexBuffer.Format} index: {j}:");
fileWriter.WriteLine($"Texcoord = " + edResourceReader.ReadUInt32().ToString("X8"));
fileWriter.WriteLine($"Texcoord = " + edResourceReader.ReadUInt32().ToString("X8"));
fileWriter.WriteLine($"Texcoord = " + edResourceReader.ReadUInt32().ToString("X8"));
fileWriter.WriteLine($"Texcoord = " + edResourceReader.ReadUInt32().ToString("X8"));
fileWriter.WriteLine($"Texcoord = " + edResourceReader.ReadUInt32().ToString("X8"));
fileWriter.WriteLine($"End of {vertexBuffer.Format} index: {j}");
fileWriter.WriteLine(Environment.NewLine);
}
break;
case VertexBufferFormat.Skinned:
for (var j = 0; j < vertexBuffer.Count; j++)
{
fileWriter.WriteLine($"{j}:");
fileWriter.WriteLine($"Position X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
fileWriter.WriteLine($"Texcoord U = " + edResourceReader.ReadSingle() + " V = " + edResourceReader.ReadSingle());
fileWriter.WriteLine($"Normal X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
fileWriter.WriteLine($"Tangent X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
fileWriter.WriteLine($"Binormal X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
edResourceReader.ReadUInt32();
edResourceReader.ReadUInt32();
}
break;
/*
* case VertexBufferFormat.Unknown1B:
* var goodCount = 0;
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* //fileWriter.WriteLine($"Index: {j}:");
* string values = $"({ edResourceReader.ReadSingle()},{ edResourceReader.ReadSingle()}," +
* $"{edResourceReader.ReadSingle()},{edResourceReader.ReadSingle()},{edResourceReader.ReadSingle()},{edResourceReader.ReadSingle()}" +
* $",{edResourceReader.ReadSingle()},{edResourceReader.ReadSingle()},{edResourceReader.ReadSingle()})";
* if(values != "(0,0,0,0,0,0,0,0,0)")
* {
* goodCount++;
* //fileWriter.WriteLine($"(1,2,3,4,5,6,7,8,9) = "+values);
* }
*
*
* /*
* fileWriter.WriteLine($"Unknown 1 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 2 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 3 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 4 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 5 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 6 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 7 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 8 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 9 = " + edResourceReader.ReadSingle());
*
* }
* //fileWriter.WriteLine($"Valid Unknown1B count = {goodCount}");
* break;
*
* case VertexBufferFormat.Unknown1A:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* //fileWriter.WriteLine($"Index: {j}:");
* //fileWriter.WriteLine($"Unknown 1 = " + edResourceReader.ReadUInt32().ToString("X8"));
* fileWriter.WriteLine($"(1,2,3) = ({edResourceReader.ReadUInt32().ToString("X8")},{edResourceReader.ReadUInt32().ToString("X8")},{edResourceReader.ReadUInt32().ToString("X8")})");
* }
* break;
*
* case VertexBufferFormat.Rigid:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* fileWriter.WriteLine($"{j}:");
* fileWriter.WriteLine($"Position X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Texcoord U = " + edResourceReader.ReadSingle() + " V = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Normal X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Tangent X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Binormal X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* }
* break;
*
* case VertexBufferFormat.StaticPerPixel:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* fileWriter.WriteLine($"{j} U = " + edResourceReader.ReadSingle() + " V = " + edResourceReader.ReadSingle());
* //fileWriter.WriteLine(Environment.NewLine);
* }
* break;
*
* case VertexBufferFormat.AmbientPrt:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* fileWriter.WriteLine($"{j} Blend weight = " + edResourceReader.ReadSingle());
* //fileWriter.WriteLine(Environment.NewLine);
* }
* break;
*
*
* case VertexBufferFormat.World:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* fileWriter.WriteLine($"{j}:");
* fileWriter.WriteLine($"Position X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Texcoord U = " + edResourceReader.ReadSingle() + " V = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Normal X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Tangent X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Binormal X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* }
* break;
*
*
*
*/
/*
* case VertexBufferFormat.QuadraticPrt:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* fileWriter.WriteLine($"{vertexBuffer.Format} index: {j}:");
* fileWriter.WriteLine($"A X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"B X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"C X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"End of {vertexBuffer.Format} index: {j}");
* fileWriter.WriteLine(Environment.NewLine);
* }
* break;
*
*
*
* case VertexBufferFormat.Unknown1B:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* fileWriter.WriteLine($"{vertexBuffer.Format} index: {j}:");
* fileWriter.WriteLine($"Unknown 1 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 2 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 3 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 4 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 5 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 6 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 7 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 8 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Unknown 9 = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"End of {vertexBuffer.Format} index: {j}");
* fileWriter.WriteLine(Environment.NewLine);
* }
* break;
*
* case VertexBufferFormat.Decorator:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* fileWriter.WriteLine($"{vertexBuffer.Format} index: {j}:");
* fileWriter.WriteLine($"Position X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Texcoord U = " + edResourceReader.ReadSingle() + " V = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"Normal X = " + edResourceReader.ReadSingle() + " Y = " + edResourceReader.ReadSingle() + " Z = " + edResourceReader.ReadSingle());
* fileWriter.WriteLine($"End of {vertexBuffer.Format} index: {j}");
* fileWriter.WriteLine(Environment.NewLine);
* }
* break;
*
* case VertexBufferFormat.LinearPrt:
* for (var j = 0; j < vertexBuffer.Count; j++)
* {
* fileWriter.WriteLine($"{vertexBuffer.Format} index: {j}:");
* fileWriter.WriteLine($"Hex : " + edResourceReader.ReadUInt32().ToString("X8"));
* fileWriter.WriteLine($"End of {vertexBuffer.Format} index: {j}");
* fileWriter.WriteLine(Environment.NewLine);
* }
* break;
*/
}
//fileWriter.WriteLine($"End of Vertex Buffer index: {i}");
//fileWriter.WriteLine(Environment.NewLine);
}
}
}
}
return(true);
}
public override object Execute(List <string> args)
{
if (args.Count < 2)
{
return(false);
}
var fieldName = args[0];
var fieldNameLow = fieldName.ToLower();
var fieldNameSnake = fieldName.ToSnakeCase();
var previousContext = ContextStack.Context;
var previousOwner = Owner;
var previousStructure = Structure;
if (fieldName.Contains("."))
{
var lastIndex = fieldName.LastIndexOf('.');
var blockName = fieldName.Substring(0, lastIndex);
fieldName = fieldName.Substring(lastIndex + 1, (fieldName.Length - lastIndex) - 1);
fieldNameLow = fieldName.ToLower();
fieldNameSnake = fieldName.ToSnakeCase();
var command = new EditBlockCommand(ContextStack, CacheContext, Tag, Owner);
if (command.Execute(new List <string> {
blockName
}).Equals(false))
{
while (ContextStack.Context != previousContext)
{
ContextStack.Pop();
}
Owner = previousOwner;
Structure = previousStructure;
return(false);
}
command = (ContextStack.Context.GetCommand("EditBlock") as EditBlockCommand);
Owner = command.Owner;
Structure = command.Structure;
if (Owner == null)
{
while (ContextStack.Context != previousContext)
{
ContextStack.Pop();
}
Owner = previousOwner;
Structure = previousStructure;
return(false);
}
}
var field = TagStructure.GetTagFieldEnumerable(Structure)
.Find(f =>
f.Name == fieldName ||
f.Name.ToLower() == fieldNameLow ||
f.Name.ToSnakeCase() == fieldNameSnake);
if (field == null)
{
Console.WriteLine("ERROR: {0} does not contain a field named \"{1}\".", Structure.Types[0].Name, fieldName);
while (ContextStack.Context != previousContext)
{
ContextStack.Pop();
}
Owner = previousOwner;
Structure = previousStructure;
return(false);
}
var fieldType = field.FieldType;
var fieldAttrs = field.GetCustomAttributes(typeof(TagFieldAttribute), false);
var fieldAttr = fieldAttrs?.Length < 1 ? new TagFieldAttribute() : (TagFieldAttribute)fieldAttrs[0];
var fieldInfo = new TagFieldInfo(field, fieldAttr, uint.MaxValue, uint.MaxValue);
var fieldValue = ParseArgs(field.FieldType, fieldInfo, args.Skip(1).ToList());
if (fieldValue != null && fieldValue.Equals(false))
{
while (ContextStack.Context != previousContext)
{
ContextStack.Pop();
}
Owner = previousOwner;
Structure = previousStructure;
return(false);
}
if (field.FieldType == typeof(PageableResource))
{
var ownerValue = field.GetValue(Owner);
if (fieldValue == null)
{
field.SetValue(Owner, null);
}
else if (ownerValue is PageableResource pageable)
{
var newLocation = ResourceLocation.None;
FileInfo resourceFile = null;
switch (fieldValue)
{
case FileInfo file:
if (!pageable.GetLocation(out newLocation))
{
newLocation = ResourceLocation.ResourcesB;
}
resourceFile = file;
break;
case ValueTuple <ResourceLocation, FileInfo> tuple:
newLocation = tuple.Item1;
resourceFile = tuple.Item2;
break;
default:
throw new FormatException(fieldValue.ToString());
}
ResourceCache oldCache = null;
if (pageable.GetLocation(out var oldLocation))
{
oldCache = CacheContext.GetResourceCache(oldLocation);
}
var newCache = CacheContext.GetResourceCache(newLocation);
var data = File.ReadAllBytes(resourceFile.FullName);
pageable.Page.UncompressedBlockSize = (uint)data.Length;
if (oldLocation == newLocation && pageable.Page.Index != -1)
{
using (var stream = CacheContext.OpenResourceCacheReadWrite(oldLocation))
{
pageable.Page.CompressedBlockSize = oldCache.Compress(stream, pageable.Page.Index, data);
}
}
else
{
using (var destStream = CacheContext.OpenResourceCacheReadWrite(newLocation))
{
pageable.Page.Index = newCache.Add(destStream, data, out pageable.Page.CompressedBlockSize);
}
pageable.ChangeLocation(newLocation);
}
pageable.DisableChecksum();
field.SetValue(Owner, fieldValue = pageable);
}
}
else
{
field.SetValue(Owner, fieldValue);
}
var typeString =
fieldType.IsGenericType ?
$"{fieldType.Name}<{fieldType.GenericTypeArguments[0].Name}>" :
fieldType.Name;
string valueString;
#if !DEBUG
try
{
#endif
if (fieldValue == null)
{
valueString = "null";
}
else if (fieldType == typeof(StringId))
{
valueString = CacheContext.GetString((StringId)fieldValue);
}
else if (fieldType == typeof(CachedTagInstance))
{
var instance = (CachedTagInstance)fieldValue;
var tagName = instance?.Name ?? $"0x{instance.Index:X4}";
valueString = $"[0x{instance.Index:X4}] {tagName}.{CacheContext.GetString(instance.Group.Name)}";
}
else if (fieldType == typeof(TagFunction))
{
var function = (TagFunction)fieldValue;
valueString = "";
foreach (var datum in function.Data)
{
valueString += datum.ToString("X2");
}
}
else if (fieldType == typeof(PageableResource))
{
var pageable = (PageableResource)fieldValue;
pageable.GetLocation(out var location);
valueString = pageable == null ? "null" : $"{{ Location: {location}, Index: 0x{pageable.Page.Index:X4}, CompressedSize: 0x{pageable.Page.CompressedBlockSize:X8} }}";
}
else if (fieldInfo.FieldType.IsArray && fieldInfo.Attribute.Length != 0)
{
valueString = fieldValue == null ? "null" : $"[{fieldInfo.Attribute.Length}] {{ ";
var valueArray = (Array)fieldValue;
if (fieldValue != null)
{
for (var i = 0; i < fieldInfo.Attribute.Length; i++)
{
valueString += $"{valueArray.GetValue(i)}{((i + 1) < fieldInfo.Attribute.Length ? "," : "")} ";
}
valueString += "}";
}
}
else if (fieldType.GetInterface(typeof(IList).Name) != null)
{
valueString =
((IList)fieldValue).Count != 0 ?
$"{{...}}[{((IList)fieldValue).Count}]" :
"null";
}
else
{
valueString = fieldValue.ToString();
}
#if !DEBUG
}
catch (Exception e)
{
valueString = $"<ERROR MESSAGE=\"{e.Message}\" />";
}
#endif
var fieldFullName = $"{field.DeclaringType.FullName}.{field.Name}".Replace("+", ".");
var documentationNode = EditTagContextFactory.Documentation.SelectSingleNode($"//member[starts-with(@name, 'F:{fieldFullName}')]");
Console.WriteLine("{0}: {1} = {2} {3}", field.Name, typeString, valueString,
documentationNode != null ?
$":: {documentationNode.FirstChild.InnerText.Replace("\r\n", "").TrimStart().TrimEnd()}" :
"");
while (ContextStack.Context != previousContext)
{
ContextStack.Pop();
}
Owner = previousOwner;
Structure = previousStructure;
return(true);
}
public object ParseArgs(Type type, TagFieldInfo info, List <string> args)
{
var input = args[0];
object output = null;
if (type == typeof(byte))
{
if (args.Count != 1)
{
return(false);
}
if (!byte.TryParse(input, out byte value))
{
return(false);
}
output = value;
}
else if (type == typeof(sbyte))
{
if (args.Count != 1)
{
return(false);
}
if (!sbyte.TryParse(input, out sbyte value))
{
return(false);
}
output = value;
}
else if (type == typeof(short))
{
if (args.Count != 1)
{
return(false);
}
if (!short.TryParse(input, out short value))
{
return(false);
}
output = value;
}
else if (type == typeof(ushort))
{
if (args.Count != 1)
{
return(false);
}
if (!ushort.TryParse(input, out ushort value))
{
return(false);
}
output = value;
}
else if (type == typeof(int))
{
if (args.Count != 1)
{
return(false);
}
if (!int.TryParse(input, out int value))
{
return(false);
}
output = value;
}
else if (type == typeof(uint))
{
if (args.Count != 1)
{
return(false);
}
if (!uint.TryParse(input, out uint value))
{
return(false);
}
output = value;
}
else if (type == typeof(long))
{
if (args.Count != 1)
{
return(false);
}
if (!long.TryParse(input, out long value))
{
return(false);
}
output = value;
}
else if (type == typeof(ulong))
{
if (args.Count != 1)
{
return(false);
}
if (!ulong.TryParse(input, out ulong value))
{
return(false);
}
output = value;
}
else if (type == typeof(float))
{
if (args.Count != 1)
{
return(false);
}
if (!float.TryParse(input, out float value))
{
return(false);
}
output = value;
}
else if (type == typeof(string))
{
if (args.Count != 1)
{
return(false);
}
output = input;
}
else if (type == typeof(CachedTagInstance))
{
if (args.Count != 1 || !CacheContext.TryGetTag(input, out var tag))
{
return(false);
}
output = tag;
}
else if (type == typeof(Tag))
{
if (args.Count != 1)
{
return(false);
}
if (!CacheContext.TryParseGroupTag(args[0], out var result))
{
Console.WriteLine($"Invalid tag group specifier: {args[0]}");
return(false);
}
output = result;
}
else if (type == typeof(StringId))
{
if (args.Count != 1)
{
return(false);
}
output = CacheContext.GetStringId(input);
}
else if (type == typeof(Angle))
{
if (args.Count != 1)
{
return(false);
}
if (!float.TryParse(input, out float value))
{
return(false);
}
output = Angle.FromDegrees(value);
}
else if (type == typeof(RealEulerAngles2d))
{
if (args.Count != 2)
{
return(false);
}
if (!float.TryParse(args[0], out float yaw) ||
!float.TryParse(args[1], out float pitch))
{
return(false);
}
output = new RealEulerAngles2d(
Angle.FromDegrees(yaw),
Angle.FromDegrees(pitch));
}
else if (type == typeof(RealEulerAngles3d))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float yaw) ||
!float.TryParse(args[1], out float pitch) ||
!float.TryParse(args[2], out float roll))
{
return(false);
}
output = new RealEulerAngles3d(
Angle.FromDegrees(yaw),
Angle.FromDegrees(pitch),
Angle.FromDegrees(roll));
}
else if (type == typeof(RealPoint2d))
{
if (args.Count != 2)
{
return(false);
}
if (!float.TryParse(args[0], out float x) ||
!float.TryParse(args[1], out float y))
{
return(false);
}
output = new RealPoint2d(x, y);
}
else if (type == typeof(RealPoint3d))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float x) ||
!float.TryParse(args[1], out float y) ||
!float.TryParse(args[2], out float z))
{
return(false);
}
output = new RealPoint3d(x, y, z);
}
else if (type == typeof(RealVector2d))
{
if (args.Count != 2)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j))
{
return(false);
}
output = new RealVector2d(i, j);
}
else if (type == typeof(RealVector3d))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float k))
{
return(false);
}
output = new RealVector3d(i, j, k);
}
else if (type == typeof(RealQuaternion))
{
if (args.Count != 4)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float k) ||
!float.TryParse(args[3], out float w))
{
return(false);
}
output = new RealQuaternion(i, j, k, w);
}
else if (type == typeof(RealPlane2d))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float d))
{
return(false);
}
output = new RealPlane2d(i, j, d);
}
else if (type == typeof(RealPlane3d))
{
if (args.Count != 4)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float k) ||
!float.TryParse(args[3], out float d))
{
return(false);
}
output = new RealPlane3d(i, j, k, d);
}
else if (type.IsEnum)
{
if (args.Count != 1)
{
return(false);
}
var query = args[0];
object found;
try
{
found = Enum.Parse(type, query);
}
catch
{
found = null;
}
var names = Enum.GetNames(type).ToList();
if (found == null)
{
var nameLow = query.ToLower();
var namesLow = names.Select(i => i.ToLower()).ToList();
found = namesLow.Find(n => n == nameLow);
if (found == null)
{
var nameSnake = query.ToSnakeCase();
var namesSnake = names.Select(i => i.ToSnakeCase()).ToList();
found = namesSnake.Find(n => n == nameSnake);
if (found == null)
{
Console.WriteLine("Invalid {0} enum option: {1}", type.Name, args[0]);
Console.WriteLine("");
Console.WriteLine("Valid options:");
foreach (var name in Enum.GetNames(type))
{
var fieldName = $"{type.FullName}.{name}".Replace("+", ".");
var documentationNode = EditTagContextFactory.Documentation.SelectSingleNode($"//member[starts-with(@name, 'F:{fieldName}')]");
Console.WriteLine("\t{0} {1}", name,
documentationNode != null ?
$":: {documentationNode.FirstChild.InnerText.Replace("\r\n", "").TrimStart().TrimEnd()}" :
"");
}
Console.WriteLine();
return(false);
}
else
{
found = Enum.Parse(type, names[namesSnake.IndexOf((string)found)]);
}
}
else
{
found = Enum.Parse(type, names[namesLow.IndexOf((string)found)]);
}
}
output = found;
}
else if (type == typeof(Bounds <>))
{
var rangeType = type.GenericTypeArguments[0];
var argCount = RangeArgCount(rangeType);
var min = ParseArgs(rangeType, null, args.Take(argCount).ToList());
if (min.Equals(false))
{
return(false);
}
var max = ParseArgs(rangeType, null, args.Skip(argCount).Take(argCount).ToList());
if (max.Equals(false))
{
return(false);
}
output = Activator.CreateInstance(type, new object[] { min, max });
}
else if (type.IsArray)
{
if (info?.FieldType == typeof(byte[]) && info?.Attribute.Length == 0)
{ // tag_data field
if (args.Count != 1)
{
return(false);
}
if (input.Length % 2 != 0)
{
return(false);
}
List <byte> bytes = new List <byte>();
for (int i = 0; i < input.Length; i = i + 2)
{
bytes.Add(Convert.ToByte(input.Substring(i, 2), 16));
}
output = bytes.ToArray();
}
else
{
if (info == null || args.Count != info.Attribute.Length)
{
return(false);
}
var elementType = info.FieldType.GetElementType();
var values = Array.CreateInstance(elementType, info.Attribute.Length);
for (var i = 0; i < info.Attribute.Length; i++)
{
values.SetValue(Convert.ChangeType(ParseArgs(elementType, null, new List <string> {
args[i]
}), elementType), i);
}
return(values);
}
}
else if (type == typeof(RealRgbColor))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float k))
{
return(false);
}
output = new RealRgbColor(i, j, k);
}
else if (type == typeof(ArgbColor))
{
if (args.Count != 4)
{
return(false);
}
if (!byte.TryParse(args[0], out byte i) ||
!byte.TryParse(args[1], out byte j) ||
!byte.TryParse(args[2], out byte k) ||
!byte.TryParse(args[3], out byte w))
{
return(false);
}
output = new ArgbColor(i, j, k, w);
}
else if (type == typeof(Bounds <Angle>))
{
if (args.Count != 2)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j))
{
return(false);
}
output = new Bounds <Angle> {
Lower = Angle.FromDegrees(i), Upper = Angle.FromDegrees(j)
};
}
else if (type == typeof(PageableResource))
{
if (args.Count < 1 || args.Count > 2)
{
return(false);
}
if (args.Count == 1)
{
switch (args[0].ToLower())
{
case "null":
output = null;
break;
default:
output = new FileInfo(args[0]);
if (!((FileInfo)output).Exists)
{
throw new FileNotFoundException(args[0]);
}
break;
}
}
else if (args.Count == 2)
{
var resourceLocation = ResourceLocation.None;
switch (args[0].ToSnakeCase())
{
case "resources":
resourceLocation = ResourceLocation.Resources;
break;
case "textures":
resourceLocation = ResourceLocation.Textures;
break;
case "textures_b":
resourceLocation = ResourceLocation.TexturesB;
break;
case "audio":
resourceLocation = ResourceLocation.Audio;
break;
case "resources_b":
resourceLocation = ResourceLocation.ResourcesB;
break;
case "render_models" when CacheContext.Version >= CacheVersion.HaloOnline235640:
resourceLocation = ResourceLocation.RenderModels;
break;
case "lightmaps" when CacheContext.Version >= CacheVersion.HaloOnline235640:
resourceLocation = ResourceLocation.Lightmaps;
break;
default:
throw new FormatException($"Invalid resource location: {args[0]}");
}
var resourceFile = new FileInfo(args[1]);
if (!resourceFile.Exists)
{
throw new FileNotFoundException(args[1]);
}
output = (resourceLocation, resourceFile);
}
else
{
throw new NotImplementedException();
}
}
else
{
Console.WriteLine($"ERROR: Not Implemented.");
return(false);
// throw new NotImplementedException();
}
return(output);
}
/// <summary>
/// Load the roles recursively for a user.
/// </summary>
/// <param name="subjectId">
/// The user to load the roles for. This cannot be negative.
/// </param>
/// <returns>
/// The roles the user is recursively a member of.
/// </returns>
/// <exception cref="ArgumentException">
/// <paramref name="subjectId"/> cannot be negative.
/// </exception>
public ISet <long> GetUserRoles(long subjectId)
{
if (subjectId < 0)
{
throw new ArgumentException(@"Invalid user ID.", nameof(subjectId));
}
EntityRef userHasRoleEntityRef;
userHasRoleEntityRef = new EntityRef(WellKnownAliases.CurrentTenant.UserHasRole);
using (new SecurityBypassContext())
{
HashSet <long> roles = null;
// Get the subject
IEntity subject = Entity.Get(subjectId);
if (Entity.Is <UserAccount>(subject))
{
// Get the relationships of the 'userHasRole' type.
IChangeTracker <IMutableIdKey> relationshipMembers = Entity.GetRelationships(new EntityRef(subjectId), userHasRoleEntityRef, Direction.Forward);
if (relationshipMembers != null)
{
roles = new HashSet <long>(relationshipMembers.Select(pair => pair.Key));
GetParentRoles(roles);
roles.UnionWith(EveryoneRoles);
}
else
{
roles = new HashSet <long>( );
}
using (CacheContext cacheContext = CacheContext.GetContext( ))
{
cacheContext.Entities.Add(subjectId);
if (roles != null)
{
cacheContext.Entities.Add(roles);
}
cacheContext.EntityInvalidatingRelationshipTypes.Add(WellKnownAliases.CurrentTenant.UserHasRole);
cacheContext.EntityInvalidatingRelationshipTypes.Add(WellKnownAliases.CurrentTenant.IncludesRoles);
}
}
else if (Entity.Is <Role>(Entity.Get(subjectId)))
{
// The subject is a role, so include just include itself, then fetch included roles.
roles = new HashSet <long>( );
roles.Add(subjectId);
GetParentRoles(roles);
roles.UnionWith(EveryoneRoles);
using (CacheContext cacheContext = CacheContext.GetContext( ))
{
cacheContext.Entities.Add(roles);
cacheContext.EntityInvalidatingRelationshipTypes.Add(WellKnownAliases.CurrentTenant.IncludesRoles);
}
}
else
{
roles = new HashSet <long>( );
}
return(roles);
}
}
private void WriteValueExpression(HsSyntaxNode expr, BinaryReader stringReader, StreamWriter scriptWriter)
{
var valueType = (HsType.Halo3ODSTValue)Enum.Parse(typeof(HsType.Halo3ODSTValue), expr.ValueType.HaloOnline.ToString());
switch (valueType)
{
case HsType.Halo3ODSTValue.FunctionName:
scriptWriter.Write(expr.StringAddress == 0 ? OpcodeLookup(expr.Opcode) : ReadScriptString(stringReader, expr.StringAddress));
break; //Trust the string table, its faster than going through the dictionary with OpcodeLookup.
case HsType.Halo3ODSTValue.Boolean:
scriptWriter.Write(expr.Data[0] == 0 ? "false" : "true");
break;
case HsType.Halo3ODSTValue.Real:
scriptWriter.Write(BitConverter.ToSingle(new[] { expr.Data[0], expr.Data[1], expr.Data[2], expr.Data[3] }, 0));
break;
case HsType.Halo3ODSTValue.Short:
scriptWriter.Write(BitConverter.ToInt16(new[] { expr.Data[0], expr.Data[1], }, 0));
break;
case HsType.Halo3ODSTValue.Long:
scriptWriter.Write(BitConverter.ToInt32(new[] { expr.Data[0], expr.Data[1], expr.Data[2], expr.Data[3] }, 0));
break;
case HsType.Halo3ODSTValue.String:
scriptWriter.Write(expr.StringAddress == 0 ? "none" : $"\"{ReadScriptString(stringReader, expr.StringAddress)}\"");
break;
case HsType.Halo3ODSTValue.Script:
scriptWriter.Write(Definition.Scripts[BitConverter.ToInt16(new[] { expr.Data[0], expr.Data[1] }, 0)].ScriptName);
break;
case HsType.Halo3ODSTValue.StringId:
scriptWriter.Write(CacheContext.GetString(new StringId(BitConverter.ToUInt32(new[] { expr.Data[0], expr.Data[1], expr.Data[2], expr.Data[3] }, 0))));
break;
case HsType.Halo3ODSTValue.GameDifficulty:
switch (BitConverter.ToInt16(new[] { expr.Data[0], expr.Data[1] }, 0))
{
case 0: scriptWriter.Write("easy"); break;
case 1: scriptWriter.Write("normal"); break;
case 2: scriptWriter.Write("heroic"); break;
case 3: scriptWriter.Write("legendary"); break;
default: throw new NotImplementedException();
}
break;
case HsType.Halo3ODSTValue.Object:
case HsType.Halo3ODSTValue.Device:
case HsType.Halo3ODSTValue.CutsceneCameraPoint:
case HsType.Halo3ODSTValue.TriggerVolume:
case HsType.Halo3ODSTValue.UnitSeatMapping:
case HsType.Halo3ODSTValue.Vehicle:
case HsType.Halo3ODSTValue.VehicleName:
scriptWriter.Write(expr.StringAddress == 0 ? "none" : $"\"{ReadScriptString(stringReader, expr.StringAddress)}\"");
break;
default:
scriptWriter.Write($"<UNIMPLEMENTED VALUE: {expr.Flags.ToString()} {expr.ValueType.ToString()}>");
break;
}
}
protected ControllerBase(ICacheClient cache)
: this()
{
Cache = cache;
CacheContext = new CacheContext(Cache);
}
/// <summary>
///
/// KEY:referrer:category:[年月日]:[小时]:[域名]
///
/// </summary>
/// <param name="dateTime"></param>
private void SyncRedisCache(DateTime dateTime)
{
var day = DateTime.Parse(dateTime.ToString("yyyy-MM-dd"));
var hour = dateTime.Hour;
var siteDomains = DbContext.Domain.Select(p => p.SiteDomain).ToList();
foreach (var domain in siteDomains)
{
//来源分类统计结果
var redisKey = string.Format("referrer:category:{0}:{1}:{2}", dateTime.ToString("yyyyMMdd"), dateTime.Hour, domain);
var redisBody = CacheContext.Get <List <OriginCategoryByHourCacheItem> >(redisKey);
if (redisBody != null && redisBody.Any())
{
foreach (var item in redisBody)
{
var lockDomain = domain;
var cacheItem = item;
var query = from p in DbContext.OriginCategory
where p.SiteDomain == lockDomain &&
p.TotalDate == day &&
p.TotalHour == hour &&
p.OriginDomain == cacheItem.OriginDomain &&
p.IndustryCode == cacheItem.IndustryCode
select p.Id;
var queryCount = query.Count();
if (queryCount == 0)
{
#region Insert
DbContext.OriginCategory.Add(new OriginCategory
{
//时间维度
SiteDomain = domain,
TotalDate = day,
TotalHour = hour,
//来源分类指标
OriginDomain = cacheItem.OriginDomain,
IndustryCode = cacheItem.IndustryCode,
TotalNumber = cacheItem.TotalNumber,
//通用指标
PageView = cacheItem.PageView,
UniqueUser = cacheItem.UniqueUser,
NewUniqueUser = cacheItem.NewUniqueUser,
NewUniqueUserRate = cacheItem.NewUniqueUserRate,
UniqueIp = cacheItem.UniqueIp,
AccessNumber = cacheItem.AccessNumber,
UserViewPageAverage = cacheItem.UserViewPageAverage,
ViewPageDeptAverage = cacheItem.ViewPageDeptAverage,
ViewPageTimeSpanAverage = cacheItem.ViewPageTimeSpanAverage,
BounceRate = cacheItem.BounceRate
});
DbContext.SaveChanges();
#endregion
}
else
{
#region update
DbContext.OriginCategory.Update(
p => p.SiteDomain == lockDomain &&
p.TotalDate == day &&
p.TotalHour == hour &&
p.OriginDomain == cacheItem.OriginDomain &&
p.IndustryCode == cacheItem.IndustryCode,
m => new OriginCategory
{
//分类指标
TotalNumber = cacheItem.TotalNumber,
//通用指标
PageView = cacheItem.PageView,
UniqueUser = cacheItem.UniqueUser,
NewUniqueUser = cacheItem.NewUniqueUser,
NewUniqueUserRate = cacheItem.NewUniqueUserRate,
UniqueIp = cacheItem.UniqueIp,
AccessNumber = cacheItem.AccessNumber,
UserViewPageAverage = cacheItem.UserViewPageAverage,
ViewPageDeptAverage = cacheItem.ViewPageDeptAverage,
ViewPageTimeSpanAverage = cacheItem.ViewPageTimeSpanAverage,
BounceRate = cacheItem.BounceRate
});
#endregion
}
}
}
}
}
public ContextProvider()
{
_cacheContext = _cacheContext ?? new CacheContext();
}
public override async ValueTask <Completion> WriteToAsync(TextWriter writer, TextEncoder encoder, TemplateContext context)
{
if (!context.AmbientValues.TryGetValue("Services", out var servicesObj))
{
throw new ArgumentException("Services missing while invoking 'cache' block");
}
var services = servicesObj as IServiceProvider;
var dynamicCache = services.GetService <IDynamicCacheService>();
var cacheScopeManager = services.GetService <ICacheScopeManager>();
var loggerFactory = services.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger <CacheStatement>();
var cacheOptions = services.GetRequiredService <IOptions <CacheOptions> >().Value;
if (dynamicCache == null || cacheScopeManager == null)
{
logger.LogInformation(@"Liquid cache block entered without an available IDynamicCacheService or ICacheScopeManager.
The contents of the cache block will not be cached.
To enable caching, make sure that a feature that contains an implementation of IDynamicCacheService and ICacheScopeManager is enabled (for example, 'Dynamic Cache').");
await writer.WriteAsync(await EvaluateStatementsAsync(encoder, context));
return(Completion.Normal);
}
var arguments = (FilterArguments)(await _arguments.EvaluateAsync(context)).ToObjectValue();
var cacheKey = arguments.At(0).ToStringValue();
var contexts = arguments["vary_by"].ToStringValue();
var tags = arguments["dependencies"].ToStringValue();
var durationString = arguments["expires_after"].ToStringValue();
var slidingDurationString = arguments["expires_sliding"].ToStringValue();
var cacheContext = new CacheContext(cacheKey)
.AddContext(contexts.Split(SplitChars, StringSplitOptions.RemoveEmptyEntries))
.AddTag(tags.Split(SplitChars, StringSplitOptions.RemoveEmptyEntries));
if (TimeSpan.TryParse(durationString, out var duration))
{
cacheContext.WithExpiryAfter(duration);
}
if (TimeSpan.TryParse(slidingDurationString, out var slidingDuration))
{
cacheContext.WithExpirySliding(slidingDuration);
}
var cacheResult = await dynamicCache.GetCachedValueAsync(cacheContext);
if (cacheResult != null)
{
await writer.WriteAsync(cacheResult);
return(Completion.Normal);
}
cacheScopeManager.EnterScope(cacheContext);
String content;
try
{
content = await EvaluateStatementsAsync(encoder, context);
}
finally
{
cacheScopeManager.ExitScope();
}
if (cacheOptions.DebugMode)
{
// No need to optimize this code as it will be used for debugging purpose.
var debugContent = new StringWriter();
debugContent.WriteLine();
debugContent.WriteLine($"<!-- CACHE BLOCK: {cacheContext.CacheId} ({Guid.NewGuid()})");
debugContent.WriteLine($" VARY BY: {String.Join(", ", cacheContext.Contexts)}");
debugContent.WriteLine($" DEPENDENCIES: {String.Join(", ", cacheContext.Tags)}");
debugContent.WriteLine($" EXPIRES ON: {cacheContext.ExpiresOn}");
debugContent.WriteLine($" EXPIRES AFTER: {cacheContext.ExpiresAfter}");
debugContent.WriteLine($" EXPIRES SLIDING: {cacheContext.ExpiresSliding}");
debugContent.WriteLine("-->");
debugContent.WriteLine(content);
debugContent.WriteLine();
debugContent.WriteLine($"<!-- END CACHE BLOCK: {cacheContext.CacheId} -->");
content = debugContent.ToString();
}
await dynamicCache.SetCachedValueAsync(cacheContext, content);
await writer.WriteAsync(content);
return(Completion.Normal);
}
public UberTripRepository(CacheContext context)
: base(context)
{
}
