public void Read(AssetStream stream)
{
StyleName = stream.ReadStringAligned();
Normal.Read(stream);
Hover.Read(stream);
Active.Read(stream);
Focused.Read(stream);
OnNormal.Read(stream);
OnHover.Read(stream);
OnActive.Read(stream);
OnFocused.Read(stream);
Border.Read(stream);
Margin.Read(stream);
Padding.Read(stream);
Overflow.Read(stream);
Font.Read(stream);
FontSize = stream.ReadInt32();
FontStyle = stream.ReadInt32();
Alignment = stream.ReadInt32();
WordWrap = stream.ReadBoolean();
RichText = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
TextClipping = stream.ReadInt32();
ImagePosition = stream.ReadInt32();
ContentOffset.Read(stream);
FixedWidth = stream.ReadSingle();
FixedHeight = stream.ReadSingle();
StretchWidth = stream.ReadBoolean();
StretchHeight = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
RootX.Read(stream);
Skeleton.Read(stream);
SkeletonPose.Read(stream);
LeftHand.Read(stream);
RightHand.Read(stream);
if (IsReadHandles(stream.Version))
{
m_handles = stream.ReadArray <Handle>();
m_colliderArray = stream.ReadArray <Collider>();
}
m_humanBoneIndex = stream.ReadInt32Array();
m_humanBoneMass = stream.ReadSingleArray();
if (IsReadColliderIndex(stream.Version))
{
m_colliderIndex = stream.ReadInt32Array();
}
Scale = stream.ReadSingle();
ArmTwist = stream.ReadSingle();
ForeArmTwist = stream.ReadSingle();
UpperLegTwist = stream.ReadSingle();
LegTwist = stream.ReadSingle();
ArmStretch = stream.ReadSingle();
LegStretch = stream.ReadSingle();
FeetSpacing = stream.ReadSingle();
HasLeftHand = stream.ReadBoolean();
HasRightHand = stream.ReadBoolean();
if (IsReadHasTDoF(stream.Version))
{
HasTDoF = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadDensity(stream.Version))
{
Density = stream.ReadSingle();
}
Material.Read(stream);
IsTrigger = stream.ReadBoolean();
if (IsReadUsedByEffector(stream.Version))
{
UsedByEffector = stream.ReadBoolean();
}
if (IsReadUsedByComposite(stream.Version))
{
UsedByComposite = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
if (IsReadOffset(stream.Version))
{
Offset.Read(stream);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Mass = stream.ReadSingle();
Drag = stream.ReadSingle();
AngularDrag = stream.ReadSingle();
UseGravity = stream.ReadBoolean();
IsKinematic = stream.ReadBoolean();
if (IsReadInterpolate(stream.Version))
{
Interpolate = (RigidbodyInterpolation)stream.ReadByte();
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadFreezeRotation(stream.Version))
{
bool freezeRotation = stream.ReadBoolean();
Constraints = freezeRotation ? RigidbodyConstraints.FreezeRotation : RigidbodyConstraints.None;
}
else
{
Constraints = (RigidbodyConstraints)stream.ReadInt32();
}
if (IsReadCollisionDetection(stream.Version))
{
CollisionDetection = (CollisionDetectionMode)stream.ReadInt32();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Strength.Read(stream);
StrengthY.Read(stream);
StrengthZ.Read(stream);
SeparateAxes = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
Frequency = stream.ReadSingle();
Damping = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
Octaves = stream.ReadInt32();
OctaveMultiplier = stream.ReadSingle();
OctaveScale = stream.ReadSingle();
Quality = stream.ReadInt32();
ScrollSpeed.Read(stream);
Remap.Read(stream);
RemapY.Read(stream);
RemapZ.Read(stream);
RemapEnabled = stream.ReadBoolean();
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadPositionAmount(stream.Version))
{
PositionAmount.Read(stream);
RotationAmount.Read(stream);
SizeAmount.Read(stream);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
DefaultAnimation.Read(stream);
if (IsReadAnimationsPaired(stream.Version))
{
m_animationsPaired = stream.ReadTupleStringTArray <PPtr <AnimationClip> >();
}
else
{
m_animations = stream.ReadArray <PPtr <AnimationClip> >();
}
WrapMode = (WrapMode)stream.ReadInt32();
PlayAutomatically = stream.ReadBoolean();
AnimatePhysics = stream.ReadBoolean();
if (IsReadAnimateOnlyIfVisible(stream.Version))
{
AnimateOnlyIfVisible = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadCullingType(stream.Version))
{
CullingType = (AnimationCullingType)stream.ReadInt32();
}
if (IsReadUserAABB(stream.Version))
{
UserAABB.Read(stream);
}
}
public void Read(AssetStream stream)
{
m_conditionConstantArray = stream.ReadArray <OffsetPtr <ConditionConstant> >();
DestinationState = stream.ReadUInt32();
if (IsReadPathID(stream.Version))
{
FullPathID = stream.ReadUInt32();
}
ID = stream.ReadUInt32();
UserID = stream.ReadUInt32();
TransitionDuration = stream.ReadSingle();
TransitionOffset = stream.ReadSingle();
if (IsReadAtomic(stream.Version))
{
Atomic = stream.ReadBoolean();
}
else
{
ExitTime = stream.ReadSingle();
HasExitTime = stream.ReadBoolean();
HasFixedDuration = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
InterruptionSource = stream.ReadInt32();
OrderedInterruption = stream.ReadBoolean();
}
if (IsCanTransitionToSelf(stream.Version))
{
CanTransitionToSelf = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
X.Read(stream);
Y.Read(stream);
Z.Read(stream);
Magnitude.Read(stream);
SeparateAxis = stream.ReadBoolean();
if (IsReadInWorldSpace(stream.Version))
{
InWorldSpace = stream.ReadBoolean();
}
if (IsReadMultiplyDragByParticleSize(stream.Version))
{
MultiplyDragByParticleSize = stream.ReadBoolean();
MultiplyDragByParticleVelocity = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
Dampen = stream.ReadSingle();
if (IsReadDrag(stream.Version))
{
Drag.Read(stream);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Width = stream.ReadInt32();
Height = stream.ReadInt32();
CompleteImageSize = stream.ReadInt32();
TextureFormat = (TextureFormat)stream.ReadInt32();
if (IsBoolMinMap(stream.Version))
{
MipMap = stream.ReadBoolean();
if (MipMap)
{
int maxSide = Math.Max(Width, Height);
MipCount = Convert.ToInt32(Math.Log(maxSide) / Math.Log(2));
}
else
{
MipCount = 1;
}
}
else
{
MipCount = stream.ReadInt32();
}
if (IsReadIsReadable(stream.Version))
{
IsReadable = stream.ReadBoolean();
}
if (IsReadReadAllowed(stream.Version))
{
ReadAllowed = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
ImageCount = stream.ReadInt32();
TextureDimension = stream.ReadInt32();
TextureSettings.Read(stream);
if (IsReadLightmapFormat(stream.Version))
{
LightmapFormat = stream.ReadInt32();
}
if (IsReadColorSpace(stream.Version))
{
ColorSpace = (ColorSpace)stream.ReadInt32();
}
m_imageData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
if (IsReadStreamData(stream.Version))
{
StreamData.Read(stream);
}
}
/*private static int GetSerializedVersion(Version version)
* {
#warning TODO: serialized version acording to read version (current 2017.3.0f3)
* return 2;
* }*/
public void Read(AssetStream stream)
{
ParentConstantIndex = stream.ReadInt32();
VolumeIndex = stream.ReadUInt32();
PitchIndex = stream.ReadUInt32();
Mute = stream.ReadBoolean();
Solo = stream.ReadBoolean();
BypassEffects = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
m_transitionConstantArray = stream.ReadArray <OffsetPtr <TransitionConstant> >();
m_blendTreeConstantIndexArray = stream.ReadInt32Array();
if (IsReadLeafInfo(stream.Version))
{
m_leafInfoArray = stream.ReadArray <LeafInfoConstant>();
}
m_blendTreeConstantArray = stream.ReadArray <OffsetPtr <BlendTreeConstant> >();
if (IsReadID(stream.Version))
{
ID = stream.ReadUInt32();
}
else
{
NameID = stream.ReadUInt32();
PathID = stream.ReadUInt32();
}
if (IsReadFullPathID(stream.Version))
{
FullPathID = stream.ReadUInt32();
}
TagID = stream.ReadUInt32();
if (IsReadSpeedParam(stream.Version))
{
SpeedParamID = stream.ReadUInt32();
MirrorParamID = stream.ReadUInt32();
CycleOffsetParamID = stream.ReadUInt32();
}
if (IsReadTimeParam(stream.Version))
{
TimeParamID = stream.ReadUInt32();
}
Speed = stream.ReadSingle();
if (IsReadCycleOffset(stream.Version))
{
CycleOffset = stream.ReadSingle();
}
IKOnFeet = stream.ReadBoolean();
if (IsReadDefaultValues(stream.Version))
{
WriteDefaultValues = stream.ReadBoolean();
}
Loop = stream.ReadBoolean();
if (IsReadMirror(stream.Version))
{
Mirror = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
X.Read(stream);
Y.Read(stream);
Z.Read(stream);
InWorldSpace = stream.ReadBoolean();
RandomizePerFrame = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
BounceScale = stream.ReadSingle();
IndirectOutputScale = stream.ReadSingle();
AlbedoBoost = stream.ReadSingle();
TemporalCoherenceThreshold = stream.ReadSingle();
EnvironmentLightingMode = stream.ReadUInt32();
EnableBakedLightmaps = stream.ReadBoolean();
EnableRealtimeLightmaps = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
TerrainData.Read(stream);
TreeDistance = stream.ReadSingle();
TreeBillboardDistance = stream.ReadSingle();
TreeCrossFadeLength = stream.ReadSingle();
TreeMaximumFullLODCount = stream.ReadInt32();
DetailObjectDistance = stream.ReadSingle();
DetailObjectDensity = stream.ReadSingle();
HeightmapPixelError = stream.ReadSingle();
SplatMapDistance = stream.ReadSingle();
HeightmapMaximumLOD = stream.ReadInt32();
CastShadows = stream.ReadBoolean();
if (IsReadDrawHeightmap(stream.Version))
{
DrawHeightmap = stream.ReadBoolean();
}
DrawTreesAndFoliage = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
if (IsReadReflectionProbeUsage(stream.Version))
{
ReflectionProbeUsage = stream.ReadInt32();
MaterialType = stream.ReadInt32();
LegacySpecular.Read(stream);
LegacyShininess = stream.ReadSingle();
}
if (IsReadDefaultSmoothness(stream.Version))
{
UseDefaultSmoothness = stream.ReadBoolean();
DefaultSmoothness = stream.ReadSingle();
}
MaterialTemplate.Read(stream);
LightmapIndex = stream.ReadUInt16();
LightmapIndexDynamic = stream.ReadUInt16();
LightmapTilingOffset.Read(stream);
LightmapTilingOffsetDynamic.Read(stream);
if (IsReadExplicitProbeSetHash(stream.Version))
{
ExplicitProbeSetHash.Read(stream);
}
if (IsReadBakeLightProbesForTrees(stream.Version))
{
BakeLightProbesForTrees = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
DynamicUVST.Read(stream);
ChunkDynamicUVST.Read(stream);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadBodyType(stream.Version))
{
BodyType = (RigidbodyType2D)stream.ReadInt32();
Simulated = stream.ReadBoolean();
UseFullKinematicContacts = stream.ReadBoolean();
}
if (IsReadUseAutoMass(stream.Version))
{
UseAutoMass = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
Mass = stream.ReadSingle();
LinearDrag = stream.ReadSingle();
AngularDrag = stream.ReadSingle();
GravityScale = stream.ReadSingle();
if (IsReadMaterial(stream.Version))
{
Material.Read(stream);
}
if (IsReadFixedAngle(stream.Version))
{
bool fixedAngle = stream.ReadBoolean();
Constraints = fixedAngle ? RigidbodyConstraints2D.FreezeRotation : RigidbodyConstraints2D.None;
}
if (IsReadIsKinematic(stream.Version))
{
bool isKinematic = stream.ReadBoolean();
BodyType = isKinematic ? RigidbodyType2D.Kinematic : RigidbodyType2D.Static;
Interpolate = (RigidbodyInterpolation2D)stream.ReadByte();
SleepingMode = (RigidbodySleepMode2D)stream.ReadByte();
CollisionDetection = (CollisionDetectionMode2D)stream.ReadByte();
stream.AlignStream(AlignType.Align4);
}
if (IsReadInterpolate(stream.Version))
{
Interpolate = (RigidbodyInterpolation2D)stream.ReadInt32();
SleepingMode = (RigidbodySleepMode2D)stream.ReadInt32();
CollisionDetection = (CollisionDetectionMode2D)stream.ReadInt32();
}
if (!IsReadFixedAngle(stream.Version))
{
Constraints = (RigidbodyConstraints2D)stream.ReadInt32();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Ratio = stream.ReadSingle();
Light.Read(stream);
RandomDistribution = stream.ReadBoolean();
Color = stream.ReadBoolean();
Range = stream.ReadBoolean();
Intensity = stream.ReadBoolean();
RangeCurve.Read(stream);
IntensityCurve.Read(stream);
MaxLights = stream.ReadInt32();
}
public void Read(AssetStream stream)
{
m_splats = stream.ReadArray <SplatPrototype>();
m_alphaTextures = stream.ReadArray <PPtr <Texture2D> >();
AlphamapResolution = stream.ReadInt32();
BaseMapResolution = stream.ReadInt32();
if (IsReadColorSpace(stream.Version))
{
ColorSpace = stream.ReadInt32();
MaterialRequiresMetallic = stream.ReadBoolean();
MaterialRequiresSmoothness = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
StartLifetime.Read(stream);
StartSpeed.Read(stream);
StartColor.Read(stream);
StartSize.Read(stream);
if (IsReadSizeAxes(stream.Version))
{
StartSizeY.Read(stream);
StartSizeZ.Read(stream);
}
if (IsReadRotationAxes(stream.Version))
{
StartRotationX.Read(stream);
StartRotationY.Read(stream);
}
StartRotation.Read(stream);
if (IsReadRandomizeRotationDirection(stream.Version))
{
RandomizeRotationDirection = stream.ReadSingle();
}
if (IsReadGravityModifierSingle(stream.Version))
{
GravityModifierSingle = stream.ReadSingle();
}
if (IsReadInheritVelocity(stream.Version))
{
InheritVelocity = stream.ReadSingle();
}
MaxNumParticles = stream.ReadInt32();
if (IsReadSize3D(stream.Version))
{
Size3D = stream.ReadBoolean();
}
if (IsReadRotation3D(stream.Version))
{
Rotation3D = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
if (!IsReadGravityModifierSingle(stream.Version))
{
GravityModifier.Read(stream);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
ControllerSize = stream.ReadUInt32();
Controller.Read(stream);
m_TOS.Clear();
m_TOS.Read(stream);
m_animationClips = stream.ReadArray <PPtr <AnimationClip> >();
if (IsReadStateMachineBehaviourVectorDescription(stream.Version))
{
StateMachineBehaviourVectorDescription.Read(stream);
m_stateMachineBehaviours = stream.ReadArray <PPtr <MonoBehaviour> >();
}
if (!IsAlignMultiThreadedStateMachine(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadMultiThreadedStateMachine(stream.Version))
{
MultiThreadedStateMachine = stream.ReadBoolean();
}
if (IsAlignMultiThreadedStateMachine(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Center.Read(stream);
Radius = stream.ReadSingle();
if (IsReadSuspensionSpringFirst(stream.Version))
{
SuspensionSpring.Read(stream);
}
SuspensionDistance = stream.ReadSingle();
if (!IsReadSuspensionSpringFirst(stream.Version))
{
SuspensionSpring.Read(stream);
}
if (IsReadForceAppPointDistance(stream.Version))
{
ForceAppPointDistance = stream.ReadSingle();
}
Mass = stream.ReadSingle();
if (IsReadWheelDampingRate(stream.Version))
{
WheelDampingRate = stream.ReadSingle();
}
ForwardFriction.Read(stream);
SidewaysFriction.Read(stream);
if (IsReadEnabled(stream.Version))
{
Enabled = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
public void Read(AssetStream stream)
{
m_transitionConstantArray = stream.ReadArray <OffsetPtr <SelectorTransitionConstant> >();
FullPathID = stream.ReadUInt32();
IsEntry = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadMode(stream.Version))
{
Mode = stream.ReadInt32();
}
FrameOverTime.Read(stream);
if (IsReadStartFrame(stream.Version))
{
StartFrame.Read(stream);
}
TilesX = stream.ReadInt32();
TilesY = stream.ReadInt32();
AnimationType = stream.ReadInt32();
RowIndex = stream.ReadInt32();
Cycles = stream.ReadSingle();
if (IsReadUvChannelMask(stream.Version))
{
UvChannelMask = stream.ReadInt32();
}
if (IsReadFlipU(stream.Version))
{
FlipU = stream.ReadSingle();
FlipV = stream.ReadSingle();
}
RandomRow = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
if (IsReadSprites(stream.Version))
{
m_sprites = stream.ReadArray <SpriteData>();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
m_scripts = stream.ReadArray <PPtr <MonoScript> >();
if (IsReadHasCompileErrors(stream.Version))
{
HasCompileErrors = stream.ReadBoolean();
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
EngineDllModDate.Read(stream);
}
if (IsReadCustomDlls(stream.Version))
{
m_customDlls = stream.ReadStringArray();
}
m_assemblyNames = stream.ReadStringArray();
if (IsReadAssemblyIdentifiers(stream.Version))
{
m_assemblyIdentifiers = stream.ReadStringArray();
}
if (IsReadAssemblyTypes(stream.Version))
{
m_assemblyTypes = stream.ReadInt32Array();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Message = stream.ReadStringAligned();
IsWarning = stream.ReadBoolean();
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Shader.Read(stream);
if (IsReadKeywords(stream.Version))
{
if (IsKeywordsArray(stream.Version))
{
m_shaderKeywordsArray = stream.ReadStringArray();
}
else
{
ShaderKeywords = stream.ReadStringAligned();
}
}
if (IsReadLightmapFlags(stream.Version))
{
LightmapFlags = stream.ReadUInt32();
if (IsReadOtherFlags(stream.Version))
{
EnableInstancingVariants = stream.ReadBoolean();
DoubleSidedGI = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadCustomRenderQueue(stream.Version))
{
CustomRenderQueue = stream.ReadInt32();
}
if (IsReadStringTagMap(stream.Version))
{
m_stringTagMap = new Dictionary <string, string>();
m_stringTagMap.Read(stream);
if (IsReadDisabledShaderPasses(stream.Version))
{
m_disabledShaderPasses = stream.ReadStringArray();
}
}
SavedProperties.Read(stream);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadMode(stream.Version))
{
Mode = (ParticleSystemTrailMode)stream.ReadInt32();
}
Ratio = stream.ReadSingle();
Lifetime.Read(stream);
MinVertexDistance = stream.ReadSingle();
TextureMode = stream.ReadInt32();
if (IsReadRibbonCount(stream.Version))
{
RibbonCount = stream.ReadInt32();
}
WorldSpace = stream.ReadBoolean();
DieWithParticles = stream.ReadBoolean();
SizeAffectsWidth = stream.ReadBoolean();
SizeAffectsLifetime = stream.ReadBoolean();
InheritParticleColor = stream.ReadBoolean();
if (IsReadGenerateLightingData(stream.Version))
{
GenerateLightingData = stream.ReadBoolean();
}
if (IsReadSplitSubEmitterRibbons(stream.Version))
{
SplitSubEmitterRibbons = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
ColorOverLifetime.Read(stream);
WidthOverTrail.Read(stream);
ColorOverTrail.Read(stream);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadCullTransparentMesh(stream.Version))
{
CullTransparentMesh = stream.ReadBoolean();
}
}
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 (IsReadExplicitDataLayout(stream.Version))
{
ExplicitDataLayout = stream.ReadInt32();
}
if (IsReadPathFlags(stream.Version))
{
PathFlags = stream.ReadInt32();
}
if (IsReadSceneHashes(stream.Version))
{
m_sceneHashes = new Dictionary <string, string>();
m_sceneHashes.Read(stream);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Size.Read(stream);
Center.Read(stream);
IsViewVolume = stream.ReadBoolean();
if (IsReadIsTargetVolume(stream.Version))
{
IsTargetVolume = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
if (IsReadTargetResolution(stream.Version))
{
TargetResolution = stream.ReadInt32();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (!IsMaterialConditional(stream.Version) || IsReadMaterial)
{
Material.Read(stream);
}
if (!IsTriggerConditional(stream.Version) || IsReadIsTrigger)
{
IsTrigger = stream.ReadBoolean();
}
if (IsReadEnabled(stream.Version))
{
Enabled = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
