public void Read(AssetReader reader)
{
RootX.Read(reader);
if (IsVector3(reader.Version))
{
LookAtPosition.Read3(reader);
}
else
{
LookAtPosition.Read(reader);
}
LookAtWeight.Read(reader);
m_goalArray = reader.ReadArray <HumanGoal>();
LeftHandPose.Read(reader);
RightHandPose.Read(reader);
m_doFArray = reader.ReadSingleArray();
if (IsReadTArray(reader.Version))
{
if (IsVector3(reader.Version))
{
m_TDoFArray = reader.ReadVector3Array();
}
else
{
m_TDoFArray = reader.ReadArray <Vector4f>();
}
}
}
public void Read(AssetReader reader)
{
RootX.Read(reader);
Skeleton.Read(reader);
SkeletonPose.Read(reader);
LeftHand.Read(reader);
RightHand.Read(reader);
if (IsReadHandles(reader.Version))
{
m_handles = reader.ReadArray <Handle>();
m_colliderArray = reader.ReadArray <Collider>();
}
m_humanBoneIndex = reader.ReadInt32Array();
m_humanBoneMass = reader.ReadSingleArray();
if (IsReadColliderIndex(reader.Version))
{
m_colliderIndex = reader.ReadInt32Array();
}
Scale = reader.ReadSingle();
ArmTwist = reader.ReadSingle();
ForeArmTwist = reader.ReadSingle();
UpperLegTwist = reader.ReadSingle();
LegTwist = reader.ReadSingle();
ArmStretch = reader.ReadSingle();
LegStretch = reader.ReadSingle();
FeetSpacing = reader.ReadSingle();
HasLeftHand = reader.ReadBoolean();
HasRightHand = reader.ReadBoolean();
if (IsReadHasTDoF(reader.Version))
{
HasTDoF = reader.ReadBoolean();
}
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
m_vertices = reader.ReadArray <Vector3f>();
m_indices = reader.ReadInt32Array();
Bounds.Read(reader);
m_nodes = reader.ReadArray <HeightMeshBVNode>();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadBakedPositions(reader.Version))
{
m_bakedPositions = reader.ReadArray <Vector3f>();
}
if (IsReadBakedCoefficientsFirst(reader.Version))
{
m_bakedCoefficients = reader.ReadArray <SphericalHarmonicsL2>();
}
Data.Read(reader);
if (!IsReadBakedCoefficientsFirst(reader.Version))
{
if (IsReadBakedCoefficients11(reader.Version))
{
m_bakedCoefficients11 = reader.ReadArray <SHCoefficientsBaked>();
}
else
{
m_bakedCoefficients = reader.ReadArray <SphericalHarmonicsL2>();
}
}
if (IsReadBakedLightOcclusion(reader.Version))
{
m_bakedLightOcclusion = reader.ReadArray <LightProbeOcclusion>();
}
}
public void Read(AssetReader reader)
{
m_renderers = reader.ReadArray <EnlightenRendererInformation>();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
m_systems = reader.ReadArray <EnlightenSystemInformation>();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadProbesets(reader.Version))
{
m_probesets = reader.ReadArray <Hash128>();
reader.AlignStream(AlignType.Align4);
}
m_systemAtlases = reader.ReadArray <EnlightenSystemAtlasInformation>();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadTerrainChunks(reader.Version))
{
m_terrainChunks = reader.ReadArray <EnlightenTerrainChunksInformation>();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
}
}
public void Read(AssetReader reader)
{
m_layerArray = reader.ReadArray <OffsetPtr <LayerConstant> >();
m_stateMachineArray = reader.ReadArray <OffsetPtr <StateMachineConstant> >();
Values.Read(reader);
DefaultValues.Read(reader);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
ControllerSize = reader.ReadUInt32();
Controller.Read(reader);
m_TOS.Clear();
m_TOS.Read(reader);
m_animationClips = reader.ReadArray <PPtr <AnimationClip> >();
if (IsReadStateMachineBehaviourVectorDescription(reader.Version))
{
StateMachineBehaviourVectorDescription.Read(reader);
m_stateMachineBehaviours = reader.ReadArray <PPtr <MonoBehaviour> >();
}
if (!IsAlignMultiThreadedStateMachine(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadMultiThreadedStateMachine(reader.Version))
{
MultiThreadedStateMachine = reader.ReadBoolean();
}
if (IsAlignMultiThreadedStateMachine(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
}
public void Read(AssetReader reader)
{
m_childPositionArray = reader.ReadArray <Vector2f>();
m_childMagnitudeArray = reader.ReadSingleArray();
m_childPairVectorArray = reader.ReadArray <Vector2f>();
m_childPairAvgMagInvArray = reader.ReadSingleArray();
m_childNeighborListArray = reader.ReadArray <MotionNeighborList>();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadPreloadTable(reader.Version))
{
m_preloadTable = reader.ReadArray <PPtr <Object> >();
}
m_container = reader.ReadStringKVPArray <AssetBundles.AssetInfo>();
MainAsset.Read(reader);
if (IsReadScriptCampatibility(reader.Version))
{
m_scriptCampatibility = reader.ReadArray <AssetBundleScriptInfo>();
}
if (IsReadClassCampatibility(reader.Version))
{
m_classCampatibility = reader.ReadInt32KVPUInt32Array();
}
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)
{
TextureSettings.Read(reader);
m_platformSettings = reader.ReadArray <TextureImporterPlatformSettings>();
PackingSettings.Read(reader);
VariantMultiplier = reader.ReadSingle();
m_packables = reader.ReadArray <PPtr <Object> >();
BindAsDefault = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
PropInfo.Read(reader);
m_subShaders = reader.ReadArray <SerializedSubShader>();
Name = reader.ReadString();
CustomEditorName = reader.ReadString();
FallbackName = reader.ReadString();
m_dependencies = reader.ReadArray <SerializedShaderDependency>();
DisableNoSubshadersMessage = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
NameIndex = reader.ReadInt32();
Index = reader.ReadInt32();
ArraySize = reader.ReadInt32();
StructSize = reader.ReadInt32();
m_vectorMembers = reader.ReadArray <VectorParameter>();
reader.AlignStream(AlignType.Align4);
m_matrixMembers = reader.ReadArray <MatrixParameter>();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
NameIndex = reader.ReadInt32();
m_matrixParams = reader.ReadArray <MatrixParameter>();
m_vectorParams = reader.ReadArray <VectorParameter>();
if (IsReadStructParams(reader.Version))
{
m_structParams = reader.ReadArray <StructParameter>();
}
Size = reader.ReadInt32();
}
public void Read(AssetReader reader)
{
m_stateConstantArray = reader.ReadArray <OffsetPtr <StateConstant> >();
m_anyStateTransitionConstantArray = reader.ReadArray <OffsetPtr <TransitionConstant> >();
if (IsReadConstantArray(reader.Version))
{
m_selectorStateConstantArray = reader.ReadArray <OffsetPtr <SelectorStateConstant> >();
}
DefaultState = (int)reader.ReadUInt32();
MotionSetCount = reader.ReadUInt32();
}
public void Read(AssetReader reader)
{
Tetrahedralization.Read(reader);
if (IsReadProbeSets(reader.Version))
{
m_probeSets = reader.ReadArray <ProbeSetIndex>();
m_positions = reader.ReadArray <Vector3f>();
}
if (IsReadNonTetrahedralizedProbeSetIndexMap(reader.Version))
{
m_nonTetrahedralizedProbeSetIndexMap.Read(reader);
}
}
public void Read(AssetReader reader)
{
m_transitionConstantArray = reader.ReadArray <OffsetPtr <TransitionConstant> >();
m_blendTreeConstantIndexArray = reader.ReadInt32Array();
if (IsReadLeafInfo(reader.Version))
{
m_leafInfoArray = reader.ReadArray <LeafInfoConstant>();
}
m_blendTreeConstantArray = reader.ReadArray <OffsetPtr <BlendTreeConstant> >();
NameID = reader.ReadUInt32();
if (IsReadPathID(reader.Version))
{
PathID = reader.ReadUInt32();
}
if (IsReadFullPathID(reader.Version))
{
FullPathID = reader.ReadUInt32();
}
TagID = reader.ReadUInt32();
if (IsReadSpeedParam(reader.Version))
{
SpeedParamID = reader.ReadUInt32();
MirrorParamID = reader.ReadUInt32();
CycleOffsetParamID = reader.ReadUInt32();
}
if (IsReadTimeParam(reader.Version))
{
TimeParamID = reader.ReadUInt32();
}
Speed = reader.ReadSingle();
if (IsReadCycleOffset(reader.Version))
{
CycleOffset = reader.ReadSingle();
}
IKOnFeet = reader.ReadBoolean();
if (IsReadDefaultValues(reader.Version))
{
WriteDefaultValues = reader.ReadBoolean();
}
Loop = reader.ReadBoolean();
if (IsReadMirror(reader.Version))
{
Mirror = reader.ReadBoolean();
}
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
m_splats = reader.ReadArray <SplatPrototype>();
m_alphaTextures = reader.ReadArray <PPtr <Texture2D> >();
AlphamapResolution = reader.ReadInt32();
BaseMapResolution = reader.ReadInt32();
if (IsReadColorSpace(reader.Version))
{
ColorSpace = reader.ReadInt32();
MaterialRequiresMetallic = reader.ReadBoolean();
MaterialRequiresSmoothness = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
}
public void Read(AssetReader reader)
{
m_genericBindings = reader.ReadArray <GenericBinding>();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
m_pptrCurveMapping = reader.ReadArray <PPtr <Object> >();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
}
public void Read(AssetReader reader)
{
BlobIndex = reader.ReadUInt32();
Channels.Read(reader);
m_keywordIndices = reader.ReadUInt16Array();
if (IsAlignKeywordIndices(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
ShaderHardwareTier = reader.ReadByte();
GpuProgramType = (ShaderGpuProgramType)reader.ReadByte();
reader.AlignStream(AlignType.Align4);
m_vectorParams = reader.ReadArray <VectorParameter>();
m_matrixParams = reader.ReadArray <MatrixParameter>();
m_textureParams = reader.ReadArray <TextureParameter>();
m_bufferParams = reader.ReadArray <BufferBinding>();
m_constantBuffers = reader.ReadArray <ConstantBuffer>();
m_constantBufferBindings = reader.ReadArray <BufferBinding>();
m_UAVParams = reader.ReadArray <UAVParameter>();
if (IsReadSamplers(reader.Version))
{
m_samplers = reader.ReadArray <SamplerParameter>();
}
if (IsReadShaderRequirements(reader.Version))
{
ShaderRequirements = reader.ReadInt32();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
m_PVSData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
m_scenes = reader.ReadArray <OcclusionScene>();
if (IsReadStaticRenderers(reader.Flags))
{
m_staticRenderers = reader.ReadArray <SceneObjectIdentifier>();
m_portals = reader.ReadArray <SceneObjectIdentifier>();
}
}
public void Read(AssetReader reader)
{
m_transitionConstantArray = reader.ReadArray <OffsetPtr <SelectorTransitionConstant> >();
FullPathID = reader.ReadUInt32();
IsEntry = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadMode(reader.Version))
{
Mode = (ParticleSystemAnimationMode)reader.ReadInt32();
}
FrameOverTime.Read(reader);
if (IsReadStartFrame(reader.Version))
{
StartFrame.Read(reader);
}
TilesX = reader.ReadInt32();
TilesY = reader.ReadInt32();
AnimationType = (ParticleSystemAnimationType)reader.ReadInt32();
RowIndex = reader.ReadInt32();
Cycles = reader.ReadSingle();
if (IsReadUvChannelMask(reader.Version))
{
UvChannelMask = reader.ReadInt32();
}
if (IsReadFlipU(reader.Version))
{
FlipU = reader.ReadSingle();
FlipV = reader.ReadSingle();
}
RandomRow = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
if (IsReadSprites(reader.Version))
{
m_sprites = reader.ReadArray <SpriteData>();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
DefaultAnimation.Read(reader);
if (IsReadAnimationsPaired(reader.Version))
{
m_animationsPaired = reader.ReadTupleStringTArray <PPtr <AnimationClip> >();
}
else
{
m_animations = reader.ReadArray <PPtr <AnimationClip> >();
}
WrapMode = (WrapMode)reader.ReadInt32();
PlayAutomatically = reader.ReadBoolean();
AnimatePhysics = reader.ReadBoolean();
if (IsReadAnimateOnlyIfVisible(reader.Version))
{
AnimateOnlyIfVisible = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadCullingType(reader.Version))
{
CullingType = (AnimationCullingType)reader.ReadInt32();
}
if (IsReadUserAABB(reader.Version))
{
UserAABB.Read(reader);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
m_mask = reader.ReadUInt32Array();
m_elements = reader.ReadArray <TransformMaskElement>();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
m_curves = reader.ReadArray <Channel>();
AClassID = (ClassIDType)reader.ReadInt32();
}
public void Read(AssetReader reader)
{
m_heights = reader.ReadInt16Array();
if (IsReadAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadShifts(reader.Version))
{
m_shifts = reader.ReadArray <Shift>();
reader.AlignStream(AlignType.Align4);
}
m_precomputedError = reader.ReadSingleArray();
m_minMaxPatchHeights = reader.ReadSingleArray();
if (IsReadDefaultPhysicMaterial(reader.Version))
{
DefaultPhysicMaterial.Read(reader);
}
Width = reader.ReadInt32();
Height = reader.ReadInt32();
if (IsReadThickness(reader.Version))
{
Thickness = reader.ReadSingle();
}
Levels = reader.ReadInt32();
Scale.Read(reader);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
Controller.Read(reader);
m_clips = reader.ReadArray <AnimationClipOverride>();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadSubEmitters(reader.Version))
{
m_subEmitters = reader.ReadArray <SubEmitterData>();
}
else
{
List <SubEmitterData> subEmitters = new List <SubEmitterData>();
PPtr <ParticleSystem> subEmitterBirth = reader.Read <PPtr <ParticleSystem> >();
if (!subEmitterBirth.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Birth, subEmitterBirth));
}
if (IsReadSecond(reader.Version))
{
PPtr <ParticleSystem> subEmitterBirth1 = reader.Read <PPtr <ParticleSystem> >();
if (!subEmitterBirth1.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Birth, subEmitterBirth1));
}
}
PPtr <ParticleSystem> subEmitterDeath = reader.Read <PPtr <ParticleSystem> >();
if (!subEmitterDeath.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Death, subEmitterDeath));
}
if (IsReadSecond(reader.Version))
{
PPtr <ParticleSystem> subEmitterDeath1 = reader.Read <PPtr <ParticleSystem> >();
if (!subEmitterDeath1.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Death, subEmitterDeath1));
}
}
PPtr <ParticleSystem> subEmitterCollision = reader.Read <PPtr <ParticleSystem> >();
if (!subEmitterCollision.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Collision, subEmitterCollision));
}
if (IsReadSecond(reader.Version))
{
PPtr <ParticleSystem> subEmitterCollision1 = reader.Read <PPtr <ParticleSystem> >();
if (!subEmitterCollision1.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Collision, subEmitterCollision1));
}
}
if (subEmitters.Count == 0)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Birth, default));
}
m_subEmitters = subEmitters.ToArray();
}
}
public void Read(AssetReader reader)
{
m_conditionConstantArray = reader.ReadArray <OffsetPtr <ConditionConstant> >();
DestinationState = (int)reader.ReadUInt32();
if (IsReadPathID(reader.Version))
{
FullPathID = reader.ReadUInt32();
}
ID = reader.ReadUInt32();
UserID = reader.ReadUInt32();
TransitionDuration = reader.ReadSingle();
TransitionOffset = reader.ReadSingle();
if (IsReadAtomic(reader.Version))
{
Atomic = reader.ReadBoolean();
}
else
{
ExitTime = reader.ReadSingle();
HasExitTime = reader.ReadBoolean();
HasFixedDuration = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
InterruptionSource = (TransitionInterruptionSource)reader.ReadInt32();
OrderedInterruption = reader.ReadBoolean();
}
if (IsCanTransitionToSelf(reader.Version))
{
CanTransitionToSelf = reader.ReadBoolean();
}
reader.AlignStream(AlignType.Align4);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
m_scripts = reader.ReadArray <PPtr <MonoScript> >();
if (IsReadHasCompileErrors(reader.Version))
{
HasCompileErrors = reader.ReadBoolean();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
EngineDllModDate.Read(reader);
}
if (IsReadCustomDlls(reader.Version))
{
m_customDlls = reader.ReadStringArray();
}
m_assemblyNames = reader.ReadStringArray();
if (IsReadAssemblyIdentifiers(reader.Version))
{
m_assemblyIdentifiers = reader.ReadStringArray();
}
if (IsReadAssemblyTypes(reader.Version))
{
m_assemblyTypes = reader.ReadInt32Array();
}
}
