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(); } }