public void Read(AssetReader reader)
{
m_nameIndices = new Dictionary <string, int>();
m_nameIndices.Read(reader);
Type = (SerializedPassType)reader.ReadInt32();
State.Read(reader);
ProgramMask = reader.ReadUInt32();
ProgVertex.Read(reader);
ProgFragment.Read(reader);
ProgGeometry.Read(reader);
ProgHull.Read(reader);
ProgDomain.Read(reader);
if (HasProgRayTracing(reader.Version))
{
ProgRayTracing.Read(reader);
}
HasInstancingVariant = reader.ReadBoolean();
reader.AlignStream();
UseName = reader.ReadString();
Name = reader.ReadString();
TextureName = reader.ReadString();
Tags.Read(reader);
}
public void Read(AssetReader reader)
{
Enabled = reader.ReadBoolean();
InitializeOnStartup = reader.ReadBoolean();
TestMode = reader.ReadBoolean();
reader.AlignStream();
if (HasEnabledPlatforms(reader.Version))
{
EnabledPlatforms = reader.ReadInt32();
}
if (HasIosGameId(reader.Version, reader.Flags))
{
IosGameId = reader.ReadString();
AndroidGameId = reader.ReadString();
}
#if UNIVERSAL
if (HasGameIds(reader.Version, reader.Flags))
{
m_gameIds = new Dictionary <string, string>();
m_gameIds.Read(reader);
}
#endif
if (HasGameId(reader.Version))
{
GameId = reader.ReadString();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
DebugLevel = reader.ReadInt32();
Sendrate = reader.ReadSingle();
m_assetToPrefab = new Dictionary <GUID, PPtr <GameObject> >();
m_assetToPrefab.Read(reader);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadPreloadTable(reader.Version))
{
m_preloadTable = reader.ReadAssetArray <PPtr <Object> >();
}
m_container = reader.ReadKVPStringTArray <AssetBundles.AssetInfo>();
MainAsset.Read(reader);
if (IsReadScriptCampatibility(reader.Version))
{
m_scriptCampatibility = reader.ReadAssetArray <AssetBundleScriptInfo>();
}
if (IsReadClassCampatibility(reader.Version))
{
m_classCampatibility = reader.ReadKVPInt32UInt32Array();
}
if (IsReadClassVersionMap(reader.Version))
{
m_classVersionMap = new Dictionary <int, int>();
m_classVersionMap.Read(reader);
}
if (IsReadRuntimeCompatibility(reader.Version))
{
RuntimeCompatibility = reader.ReadUInt32();
}
if (IsReadAssetBundleName(reader.Version))
{
AssetBundleName = reader.ReadString();
m_dependencies = reader.ReadStringArray();
}
if (IsReadIsStreamedSceneAssetBundle(reader.Version))
{
IsStreamedSceneAssetBundle = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
if (IsReadExplicitDataLayout(reader.Version))
{
ExplicitDataLayout = reader.ReadInt32();
}
if (IsReadPathFlags(reader.Version))
{
PathFlags = reader.ReadInt32();
}
if (IsReadSceneHashes(reader.Version))
{
m_sceneHashes = new Dictionary <string, string>();
m_sceneHashes.Read(reader);
}
}
public void Read(AssetReader reader)
{
m_stateMachineBehaviourRanges = new Dictionary <StateKey, StateRange>();
m_stateMachineBehaviourRanges.Read(reader);
if (IsReadStateMachineBehaviourIndices(reader.Version))
{
m_stateMachineBehaviourIndices = reader.ReadUInt32Array();
}
}
public void Read(AssetStream stream)
{
m_stateMachineBehaviourRanges = new Dictionary <StateKey, StateRange>();
m_stateMachineBehaviourRanges.Read(stream);
if (IsReadStateMachineBehaviourIndices(stream.Version))
{
m_stateMachineBehaviourIndices = stream.ReadUInt32Array();
}
}
public void Read(AssetReader reader)
{
m_texEnvs = new Dictionary <FastPropertyName, UnityTexEnv>();
m_floats = new Dictionary <FastPropertyName, float>();
m_colors = new Dictionary <FastPropertyName, ColorRGBAf>();
m_texEnvs.Read(reader);
m_floats.Read(reader);
m_colors.Read(reader);
}
public void Read(AssetReader reader)
{
m_snippets = new Dictionary <int, ShaderSnippet>();
m_snippets.Read(reader);
MeshComponentsFromSnippets = reader.ReadInt32();
HasSurfaceShaders = reader.ReadBoolean();
if (HasHasFixedFunctionShaders(reader.Version))
{
HasFixedFunctionShaders = reader.ReadBoolean();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (HasInternalIDToNameTable(reader.Version))
{
if (IncludesIDToName)
{
InternalIDToNameTable = new Dictionary <Tuple <ClassIDType, long>, string>();
InternalIDToNameTable.Read(reader, (t) => (ClassIDType)t);
}
}
else if (FileIDToRecycleNameRelevant(reader.Version))
{
if (!IsFileIDToRecycleNameConditional(reader.Version) || IncludesIDToName)
{
if (PPtr <Object> .IsLongID(reader.Version))
{
FileIDToRecycleName = new Dictionary <long, string>();
FileIDToRecycleName.Read(reader);
}
else
{
Dictionary <int, string> fileIDToRecycleName = new Dictionary <int, string>();
fileIDToRecycleName.Read(reader);
FileIDToRecycleNameInt = fileIDToRecycleName;
}
}
}
if (HasPreview(reader.Version))
{
Preview.Read(reader);
}
if (HasHash(reader.Version))
{
OldHashIdentity.Read(reader);
NewHashIdentity.Read(reader);
}
if (HasExternalObjects(reader.Version))
{
ExternalObjects = new Dictionary <SourceAssetIdentifier, PPtr <Object> >();
ExternalObjects.Read(reader);
if (IsAlignExternalObjects(reader.Version))
{
reader.AlignStream();
}
}
if (HasUsedFileIDs(reader.Version))
{
UsedFileIDs = reader.ReadInt64Array();
reader.AlignStream();
}
}
public static void Read <T>(this Dictionary <int, Dictionary <string, T> > instancedDictionary, Func <T, string> keySelector, BinaryReader br) where T : class, IBinarySaveData, new()
{
instancedDictionary.Clear();
int instancesCount = br.ReadInt32();
for (int i = 0; i < instancesCount; i++)
{
var newInstance = new Dictionary <string, T>();
var instanceId = br.ReadInt32();
newInstance.Read(keySelector, br);
instancedDictionary.Add(instanceId, newInstance);
}
}
public virtual void Inform(IResourceLoader loader)
{
if (resourceName == null)
{
// Get the dictionary lazily, does not hold up memory.
this.dictionary = new PolishStemmer().Dictionary;
}
else
{
using Stream dict = loader.OpenResource(resourceName);
using Stream meta = loader.OpenResource(DictionaryMetadata.GetExpectedMetadataFileName(resourceName));
this.dictionary = Dictionary.Read(dict, meta);
}
}
public void Read(AssetReader reader)
{
Tetrahedralization.Read(reader);
if (IsReadProbeSets(reader.Version))
{
m_probeSets = reader.ReadAssetArray <ProbeSetIndex>();
m_positions = reader.ReadAssetArray <Vector3f>();
}
if (IsReadNonTetrahedralizedProbeSetIndexMap(reader.Version))
{
m_nonTetrahedralizedProbeSetIndexMap = new Dictionary <Hash128, int>();
m_nonTetrahedralizedProbeSetIndexMap.Read(reader);
}
}
public ContextPropertyType GetPropertyType(string strName, string strNameSpace)
{
switch (_propertyType.Read(strName, strNameSpace))
{
case (PROP_PREDICATE): return(ContextPropertyType.PropPredicate);
case (PROP_PROMOTED): return(ContextPropertyType.PropPromoted);
case (PROP_WASPROMOTED): return(ContextPropertyType.PropWasPromoted);
case (PROP_WRITTEN): return(ContextPropertyType.PropWritten);
default: throw new NotSupportedException(String.Format("Value '{0}' not supported as PropertyType", _propertyType.Read(strName, strNameSpace)));
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadPreloadTable(stream.Version))
{
m_preloadTable = stream.ReadArray <PPtr <Object> >();
}
m_container = stream.ReadStringKVPArray <AssetBundles.AssetInfo>();
MainAsset.Read(stream);
if (IsReadScriptCampatibility(stream.Version))
{
m_scriptCampatibility = stream.ReadArray <AssetBundleScriptInfo>();
}
if (IsReadClassCampatibility(stream.Version))
{
m_classCampatibility = stream.ReadInt32KVPUInt32Array();
}
if (IsReadClassVersionMap(stream.Version))
{
m_classVersionMap = new Dictionary <int, int>();
m_classVersionMap.Read(stream);
}
if (IsReadRuntimeCompatibility(stream.Version))
{
RuntimeCompatibility = stream.ReadUInt32();
}
if (IsReadAssetBundleName(stream.Version))
{
AssetBundleName = stream.ReadStringAligned();
m_dependencies = stream.ReadStringArray();
}
if (IsReadIsStreamedSceneAssetBundle(stream.Version))
{
IsStreamedSceneAssetBundle = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
if (IsReadPathFlags(stream.Version))
{
PathFlags = stream.ReadInt32();
}
}
public void Read_ObjectHasValidPropertiesInBaseClass_BaseClassPropertiesAreDeserialized()
{
const string value = "42";
var dictionary = new Dictionary<string, string>
{
{"ChildProperty", value},
{"BasePropertyInternalSet", value},
{"BasePropertyPublicSet", value}
};
var deserialized = dictionary.Read<ObjectWithValidPropertiesInBaseClass>();
Assert.AreEqual(value, deserialized.ChildProperty);
Assert.AreEqual(value, deserialized.BasePropertyInternalSet);
Assert.AreEqual(value, deserialized.BasePropertyPublicSet);
}
public void Read_ObjectHasValidPropertiesInBaseClass_BaseClassPropertiesAreDeserialized()
{
const string value = "42";
var dictionary = new Dictionary <string, string>
{
{ "ChildProperty", value },
{ "BasePropertyInternalSet", value },
{ "BasePropertyPublicSet", value }
};
var deserialized = dictionary.Read <ObjectWithValidPropertiesInBaseClass>();
Assert.Equal(value, deserialized.ChildProperty);
Assert.Equal(value, deserialized.BasePropertyInternalSet);
Assert.Equal(value, deserialized.BasePropertyPublicSet);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
Shader.Read(reader);
if (IsReadKeywords(reader.Version))
{
if (IsKeywordsArray(reader.Version))
{
m_shaderKeywordsArray = reader.ReadStringArray();
}
else
{
ShaderKeywords = reader.ReadString();
}
}
if (IsReadLightmapFlags(reader.Version))
{
LightmapFlags = reader.ReadUInt32();
if (IsReadOtherFlags(reader.Version))
{
EnableInstancingVariants = reader.ReadBoolean();
DoubleSidedGI = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadCustomRenderQueue(reader.Version))
{
CustomRenderQueue = reader.ReadInt32();
}
if (IsReadStringTagMap(reader.Version))
{
m_stringTagMap = new Dictionary <string, string>();
m_stringTagMap.Read(reader);
if (IsReadDisabledShaderPasses(reader.Version))
{
m_disabledShaderPasses = reader.ReadStringArray();
}
}
SavedProperties.Read(reader);
}
private static Dictionary GetDictionary()
{
try
{
Type type = typeof(UkrainianMorfologikAnalyzer);
// LUCENENET NOTE: In Lucene, this was downloaded from Maven as a dependency
// (see https://search.maven.org/search?q=a:morfologik-ukrainian-search). However, we are embedding the file in .NET.
// Since it doesn't appear to be updated frequently, this should be okay.
string dictFile = "ukrainian.dict";
using (var dictStream = type.Assembly.FindAndGetManifestResourceStream(type, dictFile))
using (var metadataStream = type.Assembly.FindAndGetManifestResourceStream(type, DictionaryMetadata.GetExpectedMetadataFileName(dictFile)))
return(Dictionary.Read(dictStream, metadataStream));
}
catch (IOException e)
{
throw new Exception(e.ToString(), e);
}
}
private static Dictionary LoadDictionary()
{
Type type = typeof(PolishStemmer);
lock (type)
{
string dict = ResourcePath + DictionaryName;
using (var dictStream = type.Assembly.GetManifestResourceStream(dict))
using (var metadataStream = type.Assembly.GetManifestResourceStream(DictionaryMetadata.GetExpectedMetadataFileName(dict)))
{
if (dictStream == null)
{
throw new IOException("Polish dictionary resource not found.");
}
return(Dictionary.Read(dictStream, metadataStream));
}
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadScenes(reader.Version))
{
m_scenes = reader.ReadAssetArray <Scene>();
}
else
{
Tuple <bool, string>[] scenes = reader.ReadTupleBoolStringArray();
m_scenes = scenes.Select(t => new Scene(t.Item1, t.Item2)).ToArray();
}
if (IsReadConfigObjects(reader.Version))
{
m_configObjects = new Dictionary <string, PPtr <Object> >();
m_configObjects.Read(reader);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (HasDefaultReferences(reader.Version))
{
DefaultReferences = new Dictionary <string, PPtr <Object> >();
DefaultReferences.Read(reader);
}
if (HasExecutionOrder(reader.Version))
{
ExecutionOrder = reader.ReadInt16();
reader.AlignStream();
Icon = reader.ReadAsset <PPtr <Texture2D> >();
}
PostRead(reader);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadScript(stream.Flags))
{
m_defaultReferences = new Dictionary <string, PPtr <Object> >();
Script = stream.ReadStringAligned();
m_defaultReferences.Read(stream);
Icon.Read(stream);
}
if (IsReadExecutionOrder(stream.Version))
{
ExecutionOrder = stream.ReadInt32();
if (IsUInt32Hash(stream.Version))
{
PropertiesHash = stream.ReadUInt32();
}
else
{
PropertiesHash128.Read(stream);
}
}
if (IsReadPathName(stream.Version))
{
PathName = stream.ReadStringAligned();
}
ClassName = stream.ReadStringAligned();
if (IsReadNamespace(stream.Version))
{
Namespace = stream.ReadStringAligned();
}
AssemblyNameOrigin = stream.ReadStringAligned();
AssemblyName = FilenameUtils.FixAssemblyName(AssemblyNameOrigin);
if (IsReadIsEditorScript(stream.Version))
{
IsEditorScript = stream.ReadBoolean();
}
}
public void Read(AssetStream stream)
{
m_nameIndices = new Dictionary <string, int>();
m_nameIndices.Read(stream);
Type = (SerializedPassType)stream.ReadInt32();
State.Read(stream);
ProgramMask = stream.ReadUInt32();
ProgVertex.Read(stream);
ProgFragment.Read(stream);
ProgGeometry.Read(stream);
ProgHull.Read(stream);
ProgDomain.Read(stream);
HasInstancingVariant = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
UseName = stream.ReadStringAligned();
Name = stream.ReadStringAligned();
TextureName = stream.ReadStringAligned();
Tags.Read(stream);
}
public void Read(AssetReader reader)
{
m_tags = new Dictionary <string, string>();
m_tags.Read(reader);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
m_scenes = stream.ReadStringArray();
if (IsReadPreloadPlugin(stream.Version))
{
m_preloadedPlugins = stream.ReadStringArray();
}
if (IsReadEnabledVRDevices(stream.Version))
{
m_enabledVRDevices = stream.ReadStringArray();
}
if (IsReadBuildTags(stream.Version))
{
m_buildTags = stream.ReadStringArray();
BuildGUID.Read(stream);
}
if (IsReadHasRenderTexture(stream.Version))
{
HasRenderTexture = stream.ReadBoolean();
}
HasPROVersion = stream.ReadBoolean();
if (IsReadIsNoWatermarkBuild(stream.Version))
{
IsNoWatermarkBuild = stream.ReadBoolean();
IsPrototypingBuild = stream.ReadBoolean();
}
if (IsReadIsEducationalBuild(stream.Version))
{
IsEducationalBuild = stream.ReadBoolean();
}
if (IsReadIsEmbedded(stream.Version))
{
IsEmbedded = stream.ReadBoolean();
}
HasPublishingRights = stream.ReadBoolean();
if (IsReadHasShadows(stream.Version))
{
HasShadows = stream.ReadBoolean();
}
if (IsReadHasSoftShadows(stream.Version))
{
HasSoftShadows = stream.ReadBoolean();
HasLocalLightShadows = stream.ReadBoolean();
}
if (IsReadHasAdvancedVersion(stream.Version))
{
HasAdvancedVersion = stream.ReadBoolean();
EnableDynamicBatching = stream.ReadBoolean();
IsDebugBuild = stream.ReadBoolean();
}
if (IsReadUsesOnMouseEvents(stream.Version))
{
UsesOnMouseEvents = stream.ReadBoolean();
}
if (IsReadEnableMultipleDisplays(stream.Version))
{
EnableMultipleDisplays = stream.ReadBoolean();
}
if (IsReadHasOculusPlugin(stream.Version))
{
HasOculusPlugin = stream.ReadBoolean();
}
if (IsReadHasClusterRendering(stream.Version))
{
HasClusterRendering = stream.ReadBoolean();
}
if (IsAlignBools(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadBSVersion(stream.Version))
{
BSVersion = stream.ReadStringAligned();
}
if (IsReadAuthToken(stream.Version))
{
AuthToken = stream.ReadStringAligned();
}
if (IsReadRuntimeClassHashes(stream.Version))
{
if (IsRuntimeClassHashesUInt32(stream.Version))
{
m_runtimeClassHashesUInt32 = new Dictionary <int, uint>();
m_runtimeClassHashesUInt32.Read(stream);
}
else
{
m_runtimeClassHashes.Read(stream);
}
}
if (IsReadScriptHashes(stream.Version))
{
m_scriptHashes.Read(stream);
}
if (IsReadGraphicsAPIs(stream.Version))
{
m_graphicsAPIs = stream.ReadInt32Array();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadDefaultStandaloneQuality(reader.Version))
{
QualityLevel defaultStandaloneQuality = (QualityLevel)reader.ReadInt32();
QualityLevel defaultWebPlayerQuality = (QualityLevel)reader.ReadInt32();
m_perPlatformDefaultQuality = new Dictionary <string, int>();
SetDefaultPlatformQuality(m_perPlatformDefaultQuality);
m_perPlatformDefaultQuality[BuildTargetGroup.Standalone.ToExportString()] = (int)defaultStandaloneQuality;
m_perPlatformDefaultQuality[BuildTargetGroup.WebPlayer.ToExportString()] = (int)defaultStandaloneQuality;
}
if (IsReadDefaultMobileQuality(reader.Version))
{
QualityLevel defaultMobileQuality = (QualityLevel)reader.ReadInt32();
m_perPlatformDefaultQuality[BuildTargetGroup.Android.ToExportString()] = (int)defaultMobileQuality;
m_perPlatformDefaultQuality[BuildTargetGroup.iOS.ToExportString()] = (int)defaultMobileQuality;
}
CurrentQuality = reader.ReadInt32();
if (IsReadQualitySettingArray(reader.Version))
{
m_qualitySettings = reader.ReadAssetArray <QualitySetting>();
}
else
{
m_qualitySettings = new QualitySetting[6];
QualitySetting fastest = reader.ReadAsset <QualitySetting>();
fastest.Name = nameof(QualityLevel.Fastest);
m_qualitySettings[(int)QualityLevel.Fastest] = fastest;
QualitySetting fast = reader.ReadAsset <QualitySetting>();
fast.Name = nameof(QualityLevel.Fast);
m_qualitySettings[(int)QualityLevel.Fast] = fast;
QualitySetting simple = reader.ReadAsset <QualitySetting>();
simple.Name = nameof(QualityLevel.Simple);
m_qualitySettings[(int)QualityLevel.Simple] = simple;
QualitySetting good = reader.ReadAsset <QualitySetting>();
good.Name = nameof(QualityLevel.Good);
m_qualitySettings[(int)QualityLevel.Good] = good;
QualitySetting beautiful = reader.ReadAsset <QualitySetting>();
beautiful.Name = nameof(QualityLevel.Beautiful);
m_qualitySettings[(int)QualityLevel.Beautiful] = beautiful;
QualitySetting fantastic = reader.ReadAsset <QualitySetting>();
fantastic.Name = nameof(QualityLevel.Fantastic);
m_qualitySettings[(int)QualityLevel.Fantastic] = fantastic;
}
foreach (QualitySetting setting in m_qualitySettings)
{
switch (setting.Name)
{
case nameof(QualityLevel.Fastest):
case "Very Low":
QualitySetting fastest = CreateFastestSettings();
setting.Merge(fastest, reader.Version, reader.Flags);
break;
case nameof(QualityLevel.Fast):
case "Low":
QualitySetting fast = CreateFastSettings();
setting.Merge(fast, reader.Version, reader.Flags);
break;
case nameof(QualityLevel.Simple):
case "Medium":
QualitySetting simple = CreateSimpleSettings();
setting.Merge(simple, reader.Version, reader.Flags);
break;
case nameof(QualityLevel.Good):
case "High":
QualitySetting good = CreateGoodSettings();
setting.Merge(good, reader.Version, reader.Flags);
break;
case nameof(QualityLevel.Beautiful):
case "Very High":
QualitySetting beautiful = CreateBeautifulSettings();
setting.Merge(beautiful, reader.Version, reader.Flags);
break;
case nameof(QualityLevel.Fantastic):
case "Ultra":
default:
QualitySetting fantastic = CreateFantasticSettings();
setting.Merge(fantastic, reader.Version, reader.Flags);
break;
}
}
if (IsReadWebPlayer(reader.Version))
{
QualitySetting webPlayer = reader.ReadAsset <QualitySetting>();
webPlayer.Name = "WebPlayer";
}
#if UNIVERSAL
if (IsReadPerPlatformDefaultQuality(reader.Version, reader.Flags))
{
m_perPlatformDefaultQuality = new Dictionary <string, int>();
m_perPlatformDefaultQuality.Read(reader);
}
#endif
if (IsReadStrippedMaximumLODLevel(reader.Version, reader.Flags))
{
StrippedMaximumLODLevel = reader.ReadInt32();
}
}
public void ReadType()
{
Dictionary<string, object> dict = new Dictionary<string, object>();
dict.Add("Key 1", "Value 1");
dict.Add("Key 2", "Value 2");
dict.Add("Key 3", "Value 3");
var t = dict.Read<List>();
Assert.AreEqual(typeof(NUnit.Framework.List), t.GetType());
}
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
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadClassIDToTrack(reader.Version, reader.Flags))
{
m_classIDToTrack = new Dictionary <int, PPtr <BaseAnimationTrack> >();
m_classIDToTrack.Read(reader);
m_childTracks = reader.ReadAssetArray <ChildTrack>();
}
if (IsReadAnimationType(reader.Version))
{
AnimationType = (AnimationType)reader.ReadInt32();
}
if (IsReadLegacy(reader.Version))
{
Legacy = reader.ReadBoolean();
}
if (IsReadCompressed(reader.Version))
{
Compressed = reader.ReadBoolean();
}
if (IsReadUseHightQualityCurve(reader.Version))
{
UseHightQualityCurve = reader.ReadBoolean();
}
if (IsAlignCompressed(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadCurves(reader.Version))
{
m_rotationCurves = reader.ReadAssetArray <QuaternionCurve>();
}
if (IsReadCompressedRotationCurves(reader.Version))
{
m_compressedRotationCurves = reader.ReadAssetArray <CompressedAnimationCurve>();
}
if (IsReadEulerCurves(reader.Version))
{
m_eulerCurves = reader.ReadAssetArray <Vector3Curve>();
}
if (IsReadCurves(reader.Version))
{
m_positionCurves = reader.ReadAssetArray <Vector3Curve>();
m_scaleCurves = reader.ReadAssetArray <Vector3Curve>();
m_floatCurves = reader.ReadAssetArray <FloatCurve>();
}
if (IsReadPPtrCurves(reader.Version))
{
m_PPtrCurves = reader.ReadAssetArray <PPtrCurve>();
}
if (IsReadSampleRate(reader.Version))
{
SampleRate = reader.ReadSingle();
}
if (IsReadWrapMode(reader.Version))
{
WrapMode = (WrapMode)reader.ReadInt32();
}
if (IsReadBounds(reader.Version))
{
Bounds.Read(reader);
}
if (IsReadMuscleClip(reader.Version, reader.Flags))
{
MuscleClipSize = reader.ReadUInt32();
MuscleClip = new ClipMuscleConstant();
MuscleClip.Read(reader);
}
if (IsReadClipBindingConstant(reader.Version))
{
ClipBindingConstant.Read(reader);
}
#if UNIVERSAL
if (IsReadAnimationClipSettings(reader.Version, reader.Flags))
{
AnimationClipSettings = new AnimationClipSettings();
AnimationClipSettings.Read(reader);
}
if (IsReadEditorCurves(reader.Version, reader.Flags))
{
m_editorCurves = reader.ReadAssetArray <FloatCurve>();
m_eulerEditorCurves = reader.ReadAssetArray <FloatCurve>();
}
#endif
if (IsReadHasGenericRootTransform(reader.Version, reader.Flags))
{
HasGenericRootTransform = reader.ReadBoolean();
}
if (IsReadHasMotionFloatCurves(reader.Version, reader.Flags))
{
HasMotionFloatCurves = reader.ReadBoolean();
}
#if UNIVERSAL
if (IsReadGenerateMotionCurves(reader.Version, reader.Flags))
{
GenerateMotionCurves = reader.ReadBoolean();
}
#endif
if (IsReadHasGenericRootTransform(reader.Version, reader.Flags))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadEvents(reader.Version))
{
m_events = reader.ReadAssetArray <AnimationEvent>();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
#if UNIVERSAL
if (IsReadRuntimeEvents(reader.Version, reader.Flags))
{
m_runetimeEvents = reader.ReadAssetArray <AnimationEvent>();
}
#endif
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadClassIDToTrack(stream.Version))
{
m_classIDToTrack = new Dictionary <int, PPtr <BaseAnimationTrack> >();
m_classIDToTrack.Read(stream);
m_childTracks = stream.ReadArray <ChildTrack>();
}
if (IsReadAnimationType(stream.Version))
{
AnimationType = (AnimationType)stream.ReadInt32();
}
if (IsReadLegacy(stream.Version))
{
Legacy = stream.ReadBoolean();
}
if (IsReadCompressed(stream.Version))
{
Compressed = stream.ReadBoolean();
}
if (IsReadUseHightQualityCurve(stream.Version))
{
UseHightQualityCurve = stream.ReadBoolean();
}
if (IsAlignCompressed(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadCurves(stream.Version))
{
m_rotationCurves = stream.ReadArray <QuaternionCurve>();
}
if (IsReadCompressedRotationCurves(stream.Version))
{
m_compressedRotationCurves = stream.ReadArray <CompressedAnimationCurve>();
}
if (IsReadEulerCurves(stream.Version))
{
m_eulerCurves = stream.ReadArray <Vector3Curve>();
}
if (IsReadCurves(stream.Version))
{
m_positionCurves = stream.ReadArray <Vector3Curve>();
m_scaleCurves = stream.ReadArray <Vector3Curve>();
m_floatCurves = stream.ReadArray <FloatCurve>();
}
if (IsReadPPtrCurves(stream.Version))
{
m_PPtrCurves = stream.ReadArray <PPtrCurve>();
}
if (IsReadSampleRate(stream.Version))
{
SampleRate = stream.ReadSingle();
}
if (IsReadWrapMode(stream.Version))
{
WrapMode = (WrapMode)stream.ReadInt32();
}
if (IsReadBounds(stream.Version))
{
Bounds.Read(stream);
}
if (IsReadMuscleClipSize(stream.Version))
{
MuscleClipSize = stream.ReadUInt32();
MuscleClip.Read(stream);
}
if (IsReadClipBindingConstant(stream.Version))
{
ClipBindingConstant.Read(stream);
}
if (IsReadEvents(stream.Version))
{
m_events = stream.ReadArray <AnimationEvent>();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadFontImpl(reader.Version))
{
LineSpacing = reader.ReadSingle();
DefaultMaterial.Read(reader);
FontSize = reader.ReadSingle();
Texture.Read(reader);
reader.AlignStream(AlignType.Align4);
}
if (IsShortAsciiStartOffset(reader.Version))
{
AsciiStartOffset = reader.ReadInt16();
FontCountX = reader.ReadInt16();
FontCountY = reader.ReadInt16();
}
else
{
AsciiStartOffset = reader.ReadInt32();
if (IsReadFontCount(reader.Version))
{
FontCountX = reader.ReadInt32();
FontCountY = reader.ReadInt32();
}
}
if (IsReadKerning(reader.Version))
{
Kerning = reader.ReadSingle();
}
if (IsReadTracking(reader.Version))
{
Tracking = reader.ReadSingle();
}
if (!IsReadFontImpl(reader.Version))
{
LineSpacing = reader.ReadSingle();
}
if (IsReadCharacterSpacing(reader.Version))
{
CharacterSpacing = reader.ReadInt32();
CharacterPadding = reader.ReadInt32();
}
if (IsReadPerCharacterKerning(reader.Version))
{
if (IsBytePerCharacterKerning(reader.Version))
{
m_perCharacterKerningByte = reader.ReadTupleByteSingleArray();
}
else
{
m_perCharacterKerning = reader.ReadTupleIntFloatArray();
}
}
ConvertCase = reader.ReadInt32();
if (!IsReadFontImpl(reader.Version))
{
DefaultMaterial.Read(reader);
}
m_characterRects = reader.ReadArray <CharacterInfo>();
if (!IsReadFontImpl(reader.Version))
{
Texture.Read(reader);
}
if (IsReadGridFont(reader.Version))
{
if (IsGridFontFirst(reader.Version))
{
GridFont = reader.ReadBoolean();
}
}
if (IsByteKerningValues(reader.Version))
{
m_kerningValuesByte = new Dictionary <Tuple <byte, byte>, float>();
m_kerningValuesByte.Read(reader);
}
else
{
m_kerningValues.Read(reader);
}
if (IsReadPixelScale(reader.Version))
{
PixelScale = reader.ReadSingle();
reader.AlignStream(AlignType.Align4);
}
if (IsReadGridFont(reader.Version))
{
if (!IsGridFontFirst(reader.Version))
{
GridFont = reader.ReadBoolean();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
}
}
if (IsReadFontData(reader.Version))
{
m_fontData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
if (!IsReadFontImpl(reader.Version))
{
FontSize = reader.ReadSingle();
}
Ascent = reader.ReadSingle();
}
if (IsReadDescent(reader.Version))
{
Descent = reader.ReadSingle();
}
if (IsReadDefaultStyle(reader.Version))
{
DefaultStyle = (FontStyle)reader.ReadUInt32();
m_fontNames = reader.ReadStringArray();
}
if (IsReadFallbackFonts(reader.Version))
{
m_fallbackFonts = reader.ReadArray <PPtr <Font> >();
reader.AlignStream(AlignType.Align4);
FontRenderingMode = (FontRenderingMode)reader.ReadInt32();
}
if (IsReadUseLegacyBoundsCalculation(reader.Version))
{
UseLegacyBoundsCalculation = reader.ReadBoolean();
}
if (IsReadShouldRoundAdvanceValue(reader.Version))
{
ShouldRoundAdvanceValue = reader.ReadBoolean();
}
}
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();
}
}
