public override IEnumerable <Object> FetchDependencies(ISerializedFile file, bool isLog = false)
{
foreach (Object asset in base.FetchDependencies(file, isLog))
{
yield return(asset);
}
#if UNIVERSAL
if (IsReadDefaultProperties(file.Version, file.Flags))
{
yield return(DefaultProperties.FetchDependency(file, isLog, ToLogString, DefaultReferencesName));
}
if (IsReadDefaultReferences(file.Version, file.Flags))
{
foreach (PPtr <Object> reference in DefaultReferences.Values)
{
yield return(reference.FetchDependency(file, isLog, ToLogString, DefaultReferencesName));
}
}
if (IsReadIcon(file.Version, file.Flags))
{
yield return(Icon.FetchDependency(file, isLog, ToLogString, IconName));
}
#endif
}
public static string GetDefaultProperty(string annotationType)
{
string result;
DefaultProperties.TryGetValue(annotationType, out result);
return(result);
}
public StartupScanEnabledViewModel(IResolver resolver, IRegistryManager registryManager, ILoginsReader loginsReader, Action onCloseOut, bool isAutoShowPopup)
: base(resolver, null)
{
this.onCloseOut = onCloseOut;
this.onClose = OnClose;
// By default
ScanStatus = DefaultProperties.ReturnString("Onboardv4StatusUnknown");
ScanSummary = registryManager.GetScanSummary();
popupViewModel = new ScanPopupNotificationViewModel(resolver, this, OnClose);
_currentVM = mainViewModel;
bool isScanSummaryEmpty = ScanSummary.Duplicate + ScanSummary.Weak + ScanSummary.Insecure == 0;
IsScanSummaryPopupVisible = isAutoShowPopup && !isScanSummaryEmpty;
if (IsScanSummaryPopupVisible)
{
mainViewModel = new ScanNowViewModel(_resolver, OnClose, () => StartScanCommand.Execute(this));
}
else
{
mainViewModel = new ProgressScanViewModel(_resolver, loginsReader, OnClose, OnScanCompleted);
}
ClosePopup = new RelayCommand((o) =>
{
popupViewModel.LogStep(MarketingActionType.Continue);
IsScanSummaryPopupVisible = false;
CurrentVM = new ScanNowViewModel(_resolver, OnClose, () =>
{
StartScanCommand.Execute(o);
});
});
StartScanCommand = new RelayCommand((o) =>
{
mainViewModel = new ProgressScanViewModel(_resolver, loginsReader, OnClose, OnScanCompleted);
var vm = mainViewModel as ProgressScanViewModel;
if (vm != null)
{
CurrentVM = vm;
vm.StartScan(); // TODO: better move to View.Loaded event, where animation starts now
}
}
);
if (IsScanSummaryPopupVisible)
{
}
else
{
Task.Factory.StartNew(() =>
{
StartScanCommand.Execute(this);
});
}
}
/// <summary>
/// used to cahnge font color on mouse leave style
/// </summary>
/// <param name="obj"></param>
private void WeakPasswordMouseLeave(object obj)
{
if (_weakPasswordFlag == 0)
{
OneWeakPasswordForgroundColor = SecurityScoreHelper.ReturnWizardcolors(DefaultProperties.FillEllipsesColor);
WeakPasswordForgroundColor = SecurityScoreHelper.ReturnWizardcolors(DefaultProperties.SecurityScoreDynamicContentColor);
WeakPasswordFontWeight = DefaultProperties.ReturnFontWeight(DefaultProperties.NormalWeight);
WeakPasswordFontFamily = DefaultProperties.ReturnFontFamily(DefaultProperties.ProximaRegularFamily);
}
}
public IXmlConvertable CreateMemento()
{
DefaultProperties properties = new DefaultProperties();
string[] bookMarks = new string[((TextEditorControl)this.Control).Document.BookmarkManager.Marks.Count];
for (int i = 0; i < bookMarks.Length; ++i)
{
bookMarks[i] = ((TextEditorControl)this.Control).Document.BookmarkManager.Marks[i].ToString();
}
properties.SetProperty("Bookmarks", String.Join(",", bookMarks));
properties.SetProperty("CaretOffset", ((TextEditorControl)this.Control).ActiveTextAreaControl.Caret.Offset);
properties.SetProperty("VisibleLine", ((TextEditorControl)this.Control).ActiveTextAreaControl.TextArea.TextViewMargin.FirstVisibleLine);
properties.SetProperty("HighlightingLanguage", ((TextEditorControl)this.Control).Document.HighlightingStrategy.Name);
properties.SetProperty("Foldings", ((TextEditorControl)this.Control).Document.FoldingManager.SerializeToString());
return(properties);
}
/// <summary>
/// used to enable the alert popup and assign close and Open events
/// </summary>
/// <param name="obj"></param>
private void AlertNotificationClick(object obj)
{
IFeatureChecker featureChecker = Resolver.GetInstanceOf <IFeatureChecker>();
if (!featureChecker.IsEnabled(DefaultProperties.Features_Miscellaneous_ShowNotificationAndAlerts))
{
return;
}
alertPop = obj as Popup;
if (alertPop != null)
{
alertPop.IsOpen = true;
AlertButtonBackColor = DefaultProperties.AlertBackgroundcolor();
AlertBorderStrokeColor = DefaultProperties.AlertBorderStrokecolor(HiglightedBorderStrokecolor);
alertPop.Closed += alertPop_Closed;
Alert = BindingAlertData(false);
AlertHistory = BindingAlertData(true);
}
}
public void LoadDefaultNodeProperties()
{
int index = Node.FindValueInEnumNodeTypes(editNodeCaptionText.text);
//int index = Node.FindValueInEnumNodeTypes(currentEntity.label);
if (index == -1)
{
return;
}
Node.NodeTypes nodeType = (Node.NodeTypes)index;
string defaultPros = DefaultProperties.ForNode(nodeType);
//currentEntity.
editNodeProperties.text = defaultPros;
print("loading default properties for: " + nodeType.ToString());
}
private void OnScanCompleted()
{
var vm = CurrentVM as ProgressScanViewModel;
if (vm != null)
{
if (vm.Result.ScanList.Length != 0)
{
mainViewModel = new ScanResultWithItemsViewModel(_resolver, onClose, vm.Result);
ScanStatus = DefaultProperties.ReturnString("Onboardv4StatusAtRisk");
}
else
{
mainViewModel = new ScanResultNoItemsViewModel(_resolver, onClose);
ScanStatus = DefaultProperties.ReturnString("Onboardv4StatusAtRisk");
}
CurrentVM = mainViewModel;
}
}
public Notification(AlertMessage am)
{
switch (am.IconType)
{
default:
alertImage = DefaultProperties.ReturnImage(DefaultProperties.SecurityAlertIcon);
break;
}
siteName = am.Headline;
status = am.Message;
if (am.PublishedDate.HasValue)
{
int days = (int)DateTime.Now.Subtract(am.PublishedDate.Value).TotalDays;
if (days >= 365)
{
status = string.Format((string)Application.Current.Resources["OldPasswordDesktop"], days);
}
}
uuid = am.UUID;
AlertMessage = am;
}
private void InternalRun()
{
running = true;
Write($"Task {Name}");
var errors = 0;
var idx = 0;
foreach (var s in Steps)
{
if (s.Properties != null && DefaultProperties != null)
{
s.Properties = s.Properties.MergeWith(DefaultProperties);
}
else if (DefaultProperties != null)
{
s.Properties = DefaultProperties.Clone();
}
Write($"{++idx}. Step {s.Name}");
var res = false;
currentStep = s.Start(Output);
var tt = TT.Task.Run(() => res = currentStep.Wait());
tt.Wait();
if (!res)
{
errors++;
}
if (!res && Behavior == TaskBehavior.FailFirst)
{
Write($"Task terminated ({Behavior}).");
break;
}
}
Write($"Task completed. Errors: {errors}. Passed: {Steps.Count-errors}");
running = false;
}
public DynamicProperties GetPropertiesInstance(short entityType, int objId)
{
try
{
DynamicProperties newdP = new DynamicProperties();
var result = props.GetAll().Where(x => (x.entityType == entityType) && (x.objId == objId));
if (result.Any())
{
if (toPropsDTO(result.FirstOrDefault(), ref newdP))
{
return(newdP);
}
}
using (ISession Session = ConnectionHelper.CreateNewSession())
{
using (ITransaction Transaction = Session.BeginTransaction())
{
var gvar = new DBProperties();
// gvar.ID = newdP.ID; // ID should be Autogenerated by DB
gvar.entityType = (short)entityType;
gvar.objId = objId;
Dictionary <string, DynamicProperty> defProps = new Dictionary <string, DynamicProperty>();
defProps = DefaultProperties.fillProperties(ref defProps, (EntitiesEnum)entityType, -1, objId, "");
gvar.Vals = JsonConvert.SerializeObject(defProps);
gvar.updated = DateTime.UtcNow;
Session.Save(gvar);
Transaction.Commit();
if (toPropsDTO(gvar, ref newdP))
{
return(newdP);
}
}
}
}
catch (Exception e)
{
log.Error("Error: GetPropertiesInstance: " + e);
}
return(null);
}
public Jar(TraitDB traitDB, DefaultProperties defaultProperties)
{
this.traitDB = traitDB;
maleParents = new List <Fly>();
femaleParents = new List <Fly>();
progeny = new List <Fly>();
jarProperties = new Dictionary <JarProperty.PropertyType, JarProperty>();
foreach (JarProperty property in defaultProperties.getDefaultProperties(traitDB.gameManager.getGamePhase()))
{
jarProperties.Add(property.propertyType, property);
}
selectiveSurvivabilityAdvantage = new Dictionary <TraitData.TraitID, float>();
selectiveFitnessAdvantage = new Dictionary <TraitData.TraitID, float>();
statModification = new Dictionary <FlyStats.StatID, float>();
setJarStats();
tier = traitDB.gameManager.getGamePhase();
}
protected void toolStripTop_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
{
if (e.ClickedItem.Name == "toolStripButtonSaveCodeGenerateConifg")
{
try
{
SaveSetting();
MessageBox.Show("设置保存成功！");
}
catch (Exception ex)
{
MessageBox.Show("设置保存失败：" + ex.Message);
}
}
else if (e.ClickedItem.Name == "toolStripButtonConfigMygeneration")
{
DefaultProperties defaultProperties = new DefaultProperties();
defaultProperties.ShowDialog();
}
else if (e.ClickedItem.Name == "toolStripButtonSaveAs")
{
if (this.saveFileDialogConfig.ShowDialog() == DialogResult.OK)
{
SerializableHelper.BinarySerializeObjectByPath <T>(this.saveFileDialogConfig.FileName,
this.config);
}
}
else if (e.ClickedItem.Name == "toolStripButtonLoadConfig")
{
if (this.openFileDialogConfig.ShowDialog() == DialogResult.OK)
{
this.config = SerializableHelper.BinaryDeserializeObjectByPath(this.openFileDialogConfig.FileName,
this.DefaultConfig);
this.propertyGridSetting.SelectedObject = config;
}
}
}
private void SetProperties(Type type)
{
foreach (PropertyInfo property in Properties)
{
ManagedProperties.Add(property.Name, property);
FilteredProperties.Add(property.Name, property);
foreach (CustomAttributeData attribute in property.CustomAttributes)
{
switch (attribute.AttributeType.Name)
{
case nameof(UnmanagedProperty):
UnmanagedProperties.Add(property.Name, property);
ManagedProperties.Remove(property.Name);
FilteredProperties.Remove(property.Name);
break;
case nameof(AutoProperty):
AutoProperties.Add(property.Name, property);
AutoPropertyAttributes.Add(property.Name, property.GetCustomAttribute <AutoProperty>());
FilteredProperties.Remove(property.Name);
break;
case nameof(PrimaryKey):
PrimaryKeyProperty = property;
break;
case nameof(DateCreated):
DateCreatedProperty = property;
AutoProperties.Add(property.Name, property);
AutoPropertyAttributes.Add(property.Name, new AutoProperty(AutoPropertyTypes.DateTime));
FilteredProperties.Remove(property.Name);
break;
case nameof(DateModified):
DateModifiedProperty = property;
AutoProperties.Add(property.Name, property);
AutoPropertyAttributes.Add(property.Name, new AutoProperty(AutoPropertyTypes.DateTime));
FilteredProperties.Remove(property.Name);
break;
case nameof(ForeignKey):
ForeignKeyProperties.Add(property.Name, property);
ForeignKeyAttributes.Add(property.Name, property.GetCustomAttribute <ForeignKey>());
break;
case nameof(Unique):
UniqueKeyProperties.Add(property.Name, property);
break;
case nameof(Default):
DefaultProperties.Add(property.Name, property);
DefaultAttributes.Add(property.Name, property.GetCustomAttribute <Default>());
break;
case nameof(DataLength):
DataLengthProperties.Add(property.Name, property);
DataLengthAttributes.Add(property.Name, property.GetCustomAttribute <DataLength>());
break;
case nameof(ForeignData):
ForeignDataProperties.Add(property.Name, property);
ForeignDataAttributes.Add(property.Name, ConfigureForeignDataAttribute(property.GetCustomAttribute <ForeignData>(), property));
ManagedProperties.Remove(property.Name);
FilteredProperties.Remove(property.Name);
break;
default:
break;
}
}
}
PerformPropertiesValidation(type);
}
/// <summary>
/// apply transparent color when alert popup is open
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void alertPop_Closed(object sender, EventArgs e)
{
AlertButtonBackColor = DefaultProperties.TransparentColor();
AlertBorderStrokeColor = DefaultProperties.AlertBorderStrokecolor(AlertBorderStrokecolor);
}
public override void Read(AssetReader reader)
{
ReadBase(reader);
#if UNIVERSAL
if (IsReadScript(reader.Version, reader.Flags))
{
Script = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
if (IsReadDefaultProperties(reader.Version, reader.Flags))
{
DefaultProperties.Read(reader);
}
if (IsReadDefaultReferences(reader.Version, reader.Flags))
{
m_defaultReferences = new Dictionary <string, PPtr <Object> >();
m_defaultReferences.Read(reader);
}
if (IsReadIcon(reader.Version, reader.Flags))
{
Icon.Read(reader);
}
if (IsReadEditorGraphData(reader.Version, reader.Flags))
{
EditorGraphData.Read(reader);
}
#endif
if (IsReadExecutionOrder(reader.Version))
{
ExecutionOrder = reader.ReadInt32();
}
if (IsReadPropertiesHash(reader.Version, reader.Flags))
{
if (IsUInt32Hash(reader.Version))
{
uint hash = reader.ReadUInt32();
PropertiesHash = new Hash128(hash);
}
else
{
PropertiesHash.Read(reader);
}
}
if (IsReadPathName(reader.Version))
{
PathName = reader.ReadString();
}
ClassName = reader.ReadString();
if (IsReadNamespace(reader.Version))
{
Namespace = reader.ReadString();
}
if (IsReadAssemblyName(reader.Version, reader.Flags))
{
AssemblyNameOrigin = reader.ReadString();
AssemblyName = FilenameUtils.FixAssemblyName(AssemblyNameOrigin);
}
if (IsReadIsEditorScript(reader.Version))
{
IsEditorScript = reader.ReadBoolean();
}
}
public ExpertInfo InitExpert(ExpertInfo expert)
{
try
{
using (var Session = ConnectionHelper.CreateNewSession())
{
var msg = "";
var accNumber = long.Parse(expert.Account);
var terminal = data.getTerminalByNumber(Session, accNumber);
if (terminal == null)
{
msg = $"Unknown AccountNumber {expert.Account}. Please Register Account in DB.";
log.Log(msg);
expert.Magic = 0;
expert.Reason = msg;
return(expert);
}
var strSymbol = expert.Symbol;
if (strSymbol.Contains("_i"))
{
strSymbol = strSymbol.Substring(0, strSymbol.Length - 2);
}
var symbol = data.getSymbolByName(strSymbol);
if (symbol == null)
{
msg = $"Unknown Symbol {strSymbol}. Please register Symbol in DB.";
log.Log(msg);
expert.Reason = msg;
return(expert);
}
var adviser = data.getAdviser(Session, terminal.Id, symbol.Id, expert.EAName);
if (adviser == null)
{
adviser = new DBAdviser();
adviser.Name = expert.EAName;
adviser.Timeframe = expert.ChartTimeFrame;
adviser.Retired = false;
var dbt = new DBTerminal();
dbt.Id = terminal.Id;
adviser.Terminal = dbt;
adviser.Symbol = symbol;
}
else
{
expert.IsMaster = adviser.IsMaster;
}
adviser.Running = true;
if (adviser.Id <= 0)
{
data.SaveInsertAdviser(Session, adviser);
}
var dynProps = data.GetPropertiesInstance((short)EntitiesEnum.Adviser, adviser.Id);
if (dynProps == null || Utils.HasAny(dynProps.Vals) == false)
{
expert.Data = "";
}
else
{
var res = JsonConvert.DeserializeObject <Dictionary <string, DynamicProperty> >(dynProps.Vals);
var state = DefaultProperties.transformProperties(res);
expert.Data = JsonConvert.SerializeObject(state);
}
LoadSavedOrders(adviser, ref expert);
expert.Magic = adviser.Id;
SubscribeToSignals(adviser.Id);
log.Info($"Expert On <{adviser.Symbol.Name}> On TF=<{expert.ChartTimeFrame}> loaded successfully!");
}
return(expert);
}
catch (Exception e)
{
log.Error(e);
expert.Magic = 0;
}
return(expert);
}
private void ChangeImage(string resource)
{
ProductTourCurrentImage = DefaultProperties.ReturnImage(resource);
}
public override void Read(AssetReader reader)
{
if (IsSerialized(reader.Version))
{
ReadNamedObject(reader);
ParsedForm.Read(reader);
Platforms = reader.ReadArray((t) => (GPUPlatform)t);
uint[] offsets = reader.ReadUInt32Array();
uint[] compressedLengths = reader.ReadUInt32Array();
uint[] decompressedLengths = reader.ReadUInt32Array();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream();
SubProgramBlobs = new ShaderSubProgramBlob[Platforms.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < Platforms.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
memStream.Position = offset;
byte[] decompressedBuffer = new byte[decompressedLength];
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream, (int)compressedLength))
{
lz4Stream.ReadBuffer(decompressedBuffer, 0, decompressedBuffer.Length);
}
using (MemoryStream blobMem = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(blobMem, EndianType.LittleEndian, reader.Version, reader.Platform, reader.Flags))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob();
blob.Read(blobReader);
SubProgramBlobs[i] = blob;
}
}
}
}
}
else
{
base.Read(reader);
if (IsEncoded(reader.Version))
{
uint decompressedSize = reader.ReadUInt32();
int comressedSize = reader.ReadInt32();
if (comressedSize > 0 && decompressedSize > 0)
{
byte[] subProgramBlob = new byte[comressedSize];
reader.ReadBuffer(subProgramBlob, 0, comressedSize);
byte[] decompressedBuffer = new byte[decompressedSize];
using (MemoryStream memStream = new MemoryStream(subProgramBlob))
{
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream))
{
lz4Stream.ReadBuffer(decompressedBuffer, 0, decompressedBuffer.Length);
}
}
using (MemoryStream memStream = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(memStream, EndianType.LittleEndian, reader.Version, reader.Platform, reader.Flags))
{
SubProgramBlob.Read(blobReader);
}
}
}
reader.AlignStream();
}
if (HasFallback(reader.Version))
{
Fallback.Read(reader);
}
if (HasDefaultProperties(reader.Version))
{
DefaultProperties.Read(reader);
}
if (HasStaticProperties(reader.Version))
{
StaticProperties.Read(reader);
}
}
if (HasDependencies(reader.Version))
{
Dependencies = reader.ReadAssetArray <PPtr <Shader> >();
}
if (HasNonModifiableTextures(reader.Version))
{
NonModifiableTextures = new Dictionary <string, PPtr <Texture> >();
NonModifiableTextures.Read(reader);
}
if (HasShaderIsBaked(reader.Version))
{
ShaderIsBaked = reader.ReadBoolean();
reader.AlignStream();
}
#if UNIVERSAL
if (HasErrors(reader.Version, reader.Flags))
{
Errors = reader.ReadAssetArray <ShaderError>();
}
if (HasDefaultTextures(reader.Version, reader.Flags))
{
DefaultTextures = new Dictionary <string, PPtr <Texture> >();
DefaultTextures.Read(reader);
}
if (HasCompileInfo(reader.Version, reader.Flags))
{
CompileInfo.Read(reader);
}
#endif
}
public Alert(AlertNotification an)
{
resolver = ((PBApp)Application.Current).GetResolver();
if (resolver != null)
{
pbData = resolver.GetInstanceOf <IPBData>();
}
string path = AppHelper.ImageFolderLocation + an.image_id + ".png";
if (File.Exists(path))
{
alertImage = c.GetImageForPath(path, loadDefaultIfNeeded: false);
icon_width = 60;
icon_height = 40;
}
else
{
alertImage = DefaultProperties.ReturnImage(DefaultProperties.SecurityAlertIcon);
icon_width = 21;
icon_height = 18;
}
if (an.AlertType == AlertType.SecurityAlert)
{
siteName = an.site_name;
if (an.has_duplicate)
{
status = (string)Application.Current.Resources["DuplicatePassword"];
}
else if (an.is_weak)
{
status = (string)Application.Current.Resources["WeakPassword"];
}
else if (an.last_password_change.HasValue)
{
int days = (int)DateTime.Now.Subtract(an.last_password_change.Value).TotalDays;
if (days >= 365)
{
status = string.Format((string)Application.Current.Resources["OldPasswordDesktop"], days);
}
}
}
else if (an.AlertType == AlertType.NewShare)
{
siteName = an.CustomMessage;
if (pbData != null)
{
email = an.sender == pbData.ActiveUser ? an.receiver : an.sender;
visible = true;
}
status = an.nickname;// an.message;
shareStatus = an.status;
uuid = an.id;
alertImage = (ImageSource)Application.Current.FindResource("imgShare2Hover");
icon_width = 21;
icon_height = 18;
}
if (uuid == null)
{
uuid = an.secure_item_id;
}
AlertNotification = an;
}
public override void Read(AssetReader reader)
{
if (IsSerialized(reader.Version))
{
ReadBase(reader);
ParsedForm.Read(reader);
m_platforms = reader.ReadEnum32Array((t) => (GPUPlatform)t);
uint[] offsets = reader.ReadUInt32Array();
uint[] compressedLengths = reader.ReadUInt32Array();
uint[] decompressedLengths = reader.ReadUInt32Array();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
m_subProgramBlobs = new ShaderSubProgramBlob[m_platforms.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < m_platforms.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
memStream.Position = offset;
byte[] decompressedBuffer = new byte[decompressedLength];
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream, (int)compressedLength))
{
int read = lz4Stream.Read(decompressedBuffer, 0, decompressedBuffer.Length);
if (read != decompressedLength)
{
throw new Exception($"Can't properly decode shader blob. Read {read} but expected {decompressedLength}");
}
}
using (MemoryStream blobMem = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(blobMem, reader.Version, reader.Platform, reader.Flags))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob();
blob.Read(blobReader);
m_subProgramBlobs[i] = blob;
}
}
}
}
}
else
{
base.Read(reader);
if (IsEncoded(reader.Version))
{
uint decompressedSize = reader.ReadUInt32();
int comressedSize = reader.ReadInt32();
byte[] subProgramBlob = new byte[comressedSize];
reader.Read(subProgramBlob, 0, comressedSize);
reader.AlignStream(AlignType.Align4);
if (comressedSize > 0 && decompressedSize > 0)
{
byte[] decompressedBuffer = new byte[decompressedSize];
using (MemoryStream memStream = new MemoryStream(subProgramBlob))
{
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream))
{
int read = lz4Stream.Read(decompressedBuffer, 0, decompressedBuffer.Length);
if (read != decompressedSize)
{
throw new Exception($"Can't properly decode sub porgram blob. Read {read} but expected {decompressedSize}");
}
}
}
using (MemoryStream memStream = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(memStream, reader.Version, reader.Platform, reader.Flags))
{
SubProgramBlob.Read(blobReader);
}
}
}
}
if (IsReadFallback(reader.Version))
{
Fallback.Read(reader);
}
if (IsReadDefaultProperties(reader.Version))
{
DefaultProperties.Read(reader);
}
if (IsReadStaticProperties(reader.Version))
{
StaticProperties.Read(reader);
}
}
if (IsReadDependencies(reader.Version))
{
m_dependencies = reader.ReadAssetArray <PPtr <Shader> >();
}
if (IsReadNonModifiableTextures(reader.Version))
{
m_nonModifiableTextures = reader.ReadAssetArray <PPtr <Texture> >();
}
if (IsReadShaderIsBaked(reader.Version))
{
ShaderIsBaked = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetReader reader)
{
if (IsSerialized(reader.Version))
{
ReadNamedObject(reader);
ParsedForm.Read(reader);
Platforms = reader.ReadArray((t) => (GPUPlatform)t);
if (IsDoubleArray(reader.Version))
{
uint[][] offsets = reader.ReadUInt32ArrayArray();
uint[][] compressedLengths = reader.ReadUInt32ArrayArray();
uint[][] decompressedLengths = reader.ReadUInt32ArrayArray();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream();
UnpackSubProgramBlobs(reader.Layout, offsets, compressedLengths, decompressedLengths, compressedBlob);
}
else
{
uint[] offsets = reader.ReadUInt32Array();
uint[] compressedLengths = reader.ReadUInt32Array();
uint[] decompressedLengths = reader.ReadUInt32Array();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream();
UnpackSubProgramBlobs(reader.Layout, offsets, compressedLengths, decompressedLengths, compressedBlob);
}
}
else
{
base.Read(reader);
if (HasBlob(reader.Version))
{
uint decompressedSize = reader.ReadUInt32();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream();
UnpackSubProgramBlobs(reader.Layout, 0, (uint)compressedBlob.Length, decompressedSize, compressedBlob);
}
if (HasFallback(reader.Version))
{
Fallback.Read(reader);
}
if (HasDefaultProperties(reader.Version))
{
DefaultProperties.Read(reader);
}
if (HasStaticProperties(reader.Version))
{
StaticProperties.Read(reader);
}
}
if (HasDependencies(reader.Version))
{
Dependencies = reader.ReadAssetArray <PPtr <Shader> >();
}
if (HasNonModifiableTextures(reader.Version))
{
NonModifiableTextures = new Dictionary <string, PPtr <Texture> >();
NonModifiableTextures.Read(reader);
}
if (HasShaderIsBaked(reader.Version))
{
ShaderIsBaked = reader.ReadBoolean();
reader.AlignStream();
}
#if UNIVERSAL
if (HasErrors(reader.Version, reader.Flags))
{
Errors = reader.ReadAssetArray <ShaderError>();
}
if (HasDefaultTextures(reader.Version, reader.Flags))
{
DefaultTextures = new Dictionary <string, PPtr <Texture> >();
DefaultTextures.Read(reader);
}
if (HasCompileInfo(reader.Version, reader.Flags))
{
CompileInfo.Read(reader);
}
#endif
}
