public override void Read(AssetReader reader)
{
base.Read(reader);
Type = (ParticleSystemShapeType)reader.ReadInt32();
if (!IsMultimodeParameter(reader.Version))
{
float radius = reader.ReadSingle();
Radius = new MultiModeParameter(radius);
}
Angle = reader.ReadSingle();
if (HasLength(reader.Version))
{
Length = reader.ReadSingle();
}
if (HasBoxAxes(reader.Version))
{
float boxX = reader.ReadSingle();
float boxY = reader.ReadSingle();
float boxZ = reader.ReadSingle();
Scale = Type.IsBoxAny() ? new Vector3f(boxX, boxY, boxZ) : Vector3f.One;
}
if (IsMultimodeParameter(reader.Version))
{
if (HasRadiusFirst(reader.Version))
{
Radius.Read(reader);
Arc.Read(reader);
}
}
else
{
if (HasArc(reader.Version))
{
float arc = reader.ReadSingle();
Arc = new MultiModeParameter(arc);
}
}
if (HasBoxThickness(reader.Version))
{
BoxThickness.Read(reader);
RadiusThickness = reader.ReadSingle();
DonutRadius = reader.ReadSingle();
Position.Read(reader);
Rotation.Read(reader);
Scale.Read(reader);
}
PlacementMode = (PlacementMode)reader.ReadInt32();
if (HasMeshMaterialIndex(reader.Version))
{
if (HasMeshMaterialIndexFirst(reader.Version))
{
MeshMaterialIndex = reader.ReadInt32();
MeshNormalOffset = reader.ReadSingle();
}
}
if (HasMeshSpawn(reader.Version))
{
MeshSpawn.Read(reader, false);
}
Mesh.Read(reader);
if (HasMeshRenderer(reader.Version))
{
MeshRenderer.Read(reader);
SkinnedMeshRenderer.Read(reader);
}
if (HasSprite(reader.Version))
{
Sprite.Read(reader);
SpriteRenderer.Read(reader);
}
if (HasMeshMaterialIndex(reader.Version))
{
if (!HasMeshMaterialIndexFirst(reader.Version))
{
MeshMaterialIndex = reader.ReadInt32();
MeshNormalOffset = reader.ReadSingle();
}
}
if (HasMeshScale(reader.Version))
{
float meshScale = reader.ReadSingle();
Scale = new Vector3f(meshScale, meshScale, meshScale);
}
if (HasUseMeshMaterialIndex(reader.Version))
{
UseMeshMaterialIndex = reader.ReadBoolean();
UseMeshColors = reader.ReadBoolean();
}
if (HasAlignToDirection(reader.Version))
{
AlignToDirection = reader.ReadBoolean();
}
if (HasRandomDirection(reader.Version))
{
bool randomDirection = reader.ReadBoolean();
RandomDirectionAmount = randomDirection ? 1.0f : 0.0f;
}
reader.AlignStream();
if (HasTexture(reader.Version))
{
Texture.Read(reader);
TextureClipChannel = reader.ReadInt32();
TextureClipThreshold = reader.ReadSingle();
TextureUVChannel = reader.ReadInt32();
TextureColorAffectsParticles = reader.ReadBoolean();
TextureAlphaAffectsParticles = reader.ReadBoolean();
TextureBilinearFiltering = reader.ReadBoolean();
reader.AlignStream();
}
if (HasRandomDirectionAmount(reader.Version))
{
RandomDirectionAmount = reader.ReadSingle();
SphericalDirectionAmount = reader.ReadSingle();
}
if (HasRandomPositionAmount(reader.Version))
{
RandomPositionAmount = reader.ReadSingle();
}
if (IsMultimodeParameter(reader.Version))
{
if (!HasRadiusFirst(reader.Version))
{
Radius.Read(reader);
Arc.Read(reader);
}
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadLODData(reader.Version))
{
m_LODData = reader.ReadAssetArray <LOD>();
}
if (IsReadUse16bitIndices(reader.Version))
{
Use16bitIndices = reader.ReadInt32() > 0;
}
if (IsReadIndexBuffer(reader.Version))
{
if (IsReadIndexBufferFirst(reader.Version))
{
m_indexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadSubMeshes(reader.Version))
{
m_subMeshes = reader.ReadAssetArray <SubMesh>();
}
if (IsReadBlendShapes(reader.Version))
{
Shapes.Read(reader);
}
if (IsReadBindPosesFirst(reader.Version))
{
m_bindPoses = reader.ReadAssetArray <Matrix4x4f>();
}
if (IsReadBoneNameHashes(reader.Version))
{
m_boneNameHashes = reader.ReadUInt32Array();
RootBoneNameHash = reader.ReadUInt32();
}
if (IsReadBonesAABB(reader.Version))
{
m_bonesAABB = reader.ReadAssetArray <MinMaxAABB>();
VariableBoneCountWeights.Read(reader);
}
if (IsReadMeshCompression(reader.Version))
{
MeshCompression = (MeshCompression)reader.ReadByte();
}
if (IsReadStreamCompression(reader.Version))
{
StreamCompression = reader.ReadByte();
}
if (IsReadIsReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
KeepVertices = reader.ReadBoolean();
KeepIndices = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadIndexFormat(reader.Version))
{
if (IsReadIndexFormatCondition(reader.Version))
{
if (MeshCompression == 0)
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
else
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
if (IsReadIndexBuffer(reader.Version))
{
if (!IsReadIndexBufferFirst(reader.Version))
{
m_indexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadVertices(reader.Version))
{
if (IsReadVertexData(reader.Version))
{
if (MeshCompression != 0)
{
m_vertices = reader.ReadAssetArray <Vector3f>();
}
}
else
{
m_vertices = reader.ReadAssetArray <Vector3f>();
}
}
if (IsReadSkin(reader.Version))
{
m_skin = reader.ReadAssetArray <BoneWeights4>();
}
if (IsReadBindPoses(reader.Version))
{
if (!IsReadBindPosesFirst(reader.Version))
{
m_bindPoses = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (IsReadVertexData(reader.Version))
{
if (IsReadOnlyVertexData(reader.Version))
{
VertexData.Read(reader);
}
else
{
if (MeshCompression == 0)
{
VertexData.Read(reader);
}
else
{
m_UV = reader.ReadAssetArray <Vector2f>();
m_UV1 = reader.ReadAssetArray <Vector2f>();
m_tangents = reader.ReadAssetArray <Vector4f>();
m_normals = reader.ReadAssetArray <Vector3f>();
m_colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
}
else
{
m_UV = reader.ReadAssetArray <Vector2f>();
if (IsReadUV1(reader.Version))
{
m_UV1 = reader.ReadAssetArray <Vector2f>();
}
if (IsReadTangentSpace(reader.Version))
{
m_tangentSpace = reader.ReadAssetArray <Tangent>();
}
else
{
m_tangents = reader.ReadAssetArray <Vector4f>();
m_normals = reader.ReadAssetArray <Vector3f>();
}
}
if (IsReadAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadCompressedMesh(reader.Version))
{
CompressedMesh.Read(reader);
}
LocalAABB.Read(reader);
if (IsReadColors(reader.Version))
{
if (!IsReadVertexData(reader.Version))
{
m_colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
if (IsReadCollisionTriangles(reader.Version))
{
m_collisionTriangles = reader.ReadUInt32Array();
CollisionVertexCount = reader.ReadInt32();
}
if (IsReadMeshUsageFlags(reader.Version))
{
MeshUsageFlags = reader.ReadInt32();
}
if (IsReadCollision(reader.Version))
{
CollisionData.Read(reader);
}
if (IsReadMeshMetrics(reader.Version))
{
m_meshMetrics = new float[2];
m_meshMetrics[0] = reader.ReadSingle();
m_meshMetrics[1] = reader.ReadSingle();
}
#if UNIVERSAL
if (IsReadMeshOptimized(reader.Version, reader.Flags))
{
MeshOptimizationFlags = reader.ReadBoolean() ? MeshOptimizationFlags.Everything : 0;
}
else if (IsReadMeshOptimizationFlags(reader.Version, reader.Flags))
{
MeshOptimizationFlags = (MeshOptimizationFlags)reader.ReadInt32();
}
#endif
if (IsReadStreamData(reader.Version))
{
reader.AlignStream(AlignType.Align4);
StreamData.Read(reader);
}
}
public void Read(AssetReader reader)
{
Min.Read(reader);
Max.Read(reader);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
GameObject.Read(reader);
}
public void Read2(AssetReader reader)
{
X = reader.ReadSingle();
Y = reader.ReadSingle();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
LengthInSec = reader.ReadSingle();
if (IsStartDelayFirst(reader.Version))
{
if (IsReadStartDelaySingle(reader.Version))
{
StartDelaySingle = reader.ReadSingle();
}
else
{
StartDelay.Read(reader);
}
}
SimulationSpeed = reader.ReadSingle();
if (IsReadStopAction(reader.Version))
{
StopAction = (ParticleSystemStopAction)reader.ReadInt32();
}
if (IsRandomSeedFirst(reader.Version))
{
RandomSeed = unchecked ((int)reader.ReadUInt32());
}
if (IsReadCullingMode(reader.Version))
{
CullingMode = (ParticleSystemCullingMode)reader.ReadInt32();
RingBufferMode = (ParticleSystemRingBufferMode)reader.ReadInt32();
RingBufferLoopRange.Read(reader);
}
Looping = reader.ReadBoolean();
Prewarm = reader.ReadBoolean();
PlayOnAwake = reader.ReadBoolean();
if (IsReadUseUnscaledTime(reader.Version))
{
UseUnscaledTime = reader.ReadBoolean();
}
if (IsMoveWithTransformBool(reader.Version))
{
MoveWithTransform = reader.ReadBoolean() ? ParticleSystemSimulationSpace.Local : ParticleSystemSimulationSpace.World;
}
if (IsReadAutoRandomSeed(reader.Version))
{
AutoRandomSeed = reader.ReadBoolean();
}
if (IsReadUseRigidbodyForVelocity(reader.Version))
{
UseRigidbodyForVelocity = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (!IsStartDelayFirst(reader.Version))
{
StartDelay.Read(reader);
reader.AlignStream(AlignType.Align4);
}
if (!IsMoveWithTransformBool(reader.Version))
{
MoveWithTransform = (ParticleSystemSimulationSpace)reader.ReadInt32();
reader.AlignStream(AlignType.Align4);
}
if (IsReadMoveWithCustomTransform(reader.Version))
{
MoveWithCustomTransform.Read(reader);
}
if (IsReadScalingMode(reader.Version))
{
ScalingMode = (ParticleSystemScalingMode)reader.ReadInt32();
}
if (!IsRandomSeedFirst(reader.Version))
{
RandomSeed = reader.ReadInt32();
}
InitialModule.Read(reader);
ShapeModule.Read(reader);
EmissionModule.Read(reader);
SizeModule.Read(reader);
RotationModule.Read(reader);
ColorModule.Read(reader);
UVModule.Read(reader);
VelocityModule.Read(reader);
if (IsReadInheritVelocityModule(reader.Version))
{
InheritVelocityModule.Read(reader);
}
ForceModule.Read(reader);
if (IsReadExternalForcesModule(reader.Version))
{
ExternalForcesModule.Read(reader);
}
ClampVelocityModule.Read(reader);
if (IsReadNoiseModule(reader.Version))
{
NoiseModule.Read(reader);
}
SizeBySpeedModule.Read(reader);
RotationBySpeedModule.Read(reader);
ColorBySpeedModule.Read(reader);
CollisionModule.Read(reader);
if (IsReadTriggerModule(reader.Version))
{
TriggerModule.Read(reader);
}
SubModule.Read(reader);
if (IsReadLightsModule(reader.Version))
{
LightsModule.Read(reader);
TrailModule.Read(reader);
}
if (IsReadCustomDataModule(reader.Version))
{
CustomDataModule.Read(reader);
}
}
public virtual void Read(AssetReader reader)
{
Enabled = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
m_constants = reader.ReadSingleArray();
}
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.ReadTupleIntSingleArray();
}
}
ConvertCase = reader.ReadInt32();
if (!IsReadFontImpl(reader.Version))
{
DefaultMaterial.Read(reader);
}
m_characterRects = reader.ReadAssetArray <CharacterInfo>();
if (!IsReadFontImpl(reader.Version))
{
Texture.Read(reader);
}
if (IsReadGridFont(reader.Version))
{
if (IsGridFontFirst(reader.Version))
{
GridFont = reader.ReadBoolean();
}
}
#warning TODO: dictionary with non unique keys
if (IsByteKerningValues(reader.Version))
{
Dictionary <Tuple <byte, byte>, float> kerningValues = new Dictionary <Tuple <byte, byte>, float>();
kerningValues.ReadSafe(reader);
foreach (var kvp in kerningValues)
{
Tuple <ushort, ushort> key = new Tuple <ushort, ushort>(kvp.Key.Item1, kvp.Key.Item2);
m_kerningValues.Add(key, kvp.Value);
}
}
else
{
m_kerningValues.ReadSafe(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.ReadAssetArray <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)
{
base.Read(reader);
if (IsReadDeferred(reader.Version))
{
Deferred.Read(reader);
}
if (IsReadDeferredReflections(reader.Version))
{
DeferredReflections.Read(reader);
}
if (IsReadScreenSpaceShadows(reader.Version))
{
ScreenSpaceShadows.Read(reader);
}
if (IsReadLegacyDeferred(reader.Version))
{
LegacyDeferred.Read(reader);
}
if (IsReadDepthNormals(reader.Version))
{
DepthNormals.Read(reader);
MotionVectors.Read(reader);
LightHalo.Read(reader);
LensFlare.Read(reader);
}
if (IsReadAlwaysIncludedShaders(reader.Version))
{
m_alwaysIncludedShaders = reader.ReadAssetArray <PPtr <Shader> >();
}
if (IsReadPreloadedShaders(reader.Version))
{
m_preloadedShaders = reader.ReadAssetArray <PPtr <ShaderVariantCollection> >();
}
if (IsReadSpritesDefaultMaterial(reader.Version))
{
SpritesDefaultMaterial.Read(reader);
}
if (IsReadCustomRenderPipeline(reader.Version))
{
CustomRenderPipeline.Read(reader);
TransparencySortMode = (TransparencySortMode)reader.ReadInt32();
TransparencySortAxis.Read(reader);
}
if (IsReadTierSettings(reader.Version))
{
if (IsReadPlatformSettings(reader.Version))
{
if (IsReadPlatformSettingsTiers(reader.Version))
{
m_platformSettings = new PlatformShaderSettings[3];
m_platformSettings[0] = reader.ReadAsset <PlatformShaderSettings>();
m_platformSettings[1] = reader.ReadAsset <PlatformShaderSettings>();
m_platformSettings[2] = reader.ReadAsset <PlatformShaderSettings>();
}
else
{
m_platformSettings = new PlatformShaderSettings[1];
m_platformSettings[0] = reader.ReadAsset <PlatformShaderSettings>();
}
}
else
{
if (IsReadStaticTierGraphicsSettings(reader.Version, reader.Flags))
{
m_tierGraphicSettings = new TierGraphicsSettings[3];
m_tierGraphicSettings[0] = reader.ReadAsset <TierGraphicsSettings>();
m_tierGraphicSettings[1] = reader.ReadAsset <TierGraphicsSettings>();
m_tierGraphicSettings[2] = reader.ReadAsset <TierGraphicsSettings>();
}
}
}
#if UNIVERSAL
if (IsReadEditorSettings(reader.Flags))
{
if (IsReadDefaultRenderingPath(reader.Version))
{
DefaultRenderingPath = (RenderingPath)reader.ReadInt32();
DefaultMobileRenderingPath = (RenderingPath)reader.ReadInt32();
}
if (IsReadTierSettings(reader.Version))
{
m_tierSettings = reader.ReadAssetArray <TierSettings>();
}
if (IsReadLightmapStripping(reader.Version))
{
LightmapStripping = (LightmapStrippingMode)reader.ReadInt32();
}
if (IsReadFogStripping(reader.Version))
{
if (IsReadFogStrippingFirst(reader.Version))
{
FogStripping = (LightmapStrippingMode)reader.ReadInt32();
}
}
if (IsReadInstancingStripping(reader.Version))
{
InstancingStripping = (InstancingStrippingVariant)reader.ReadInt32();
}
if (IsReadLightmapKeepPlain(reader.Version))
{
LightmapKeepPlain = reader.ReadBoolean();
LightmapKeepDirCombined = reader.ReadBoolean();
}
if (IsReadLightmapKeepDirSeparate(reader.Version))
{
LightmapKeepDirSeparate = reader.ReadBoolean();
}
if (IsReadLightmapKeepDynamicPlain(reader.Version))
{
if (IsReadLightmapKeepDynamic(reader.Version))
{
bool lightmapKeepDynamic = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
LightmapKeepDynamicPlain = lightmapKeepDynamic;
LightmapKeepDynamicDirCombined = lightmapKeepDynamic;
LightmapKeepDynamicDirSeparate = lightmapKeepDynamic;
}
else
{
LightmapKeepDynamicPlain = reader.ReadBoolean();
LightmapKeepDynamicDirCombined = reader.ReadBoolean();
}
}
if (IsReadLightmapKeepDynamicDirSeparate(reader.Version))
{
LightmapKeepDynamicDirSeparate = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadLightmapKeepShadowMask(reader.Version))
{
LightmapKeepShadowMask = reader.ReadBoolean();
LightmapKeepSubtractive = reader.ReadBoolean();
}
if (IsReadFogStripping(reader.Version))
{
if (!IsReadFogStrippingFirst(reader.Version))
{
FogStripping = (LightmapStrippingMode)reader.ReadInt32();
}
}
if (IsReadFogKeepLinear(reader.Version))
{
FogKeepLinear = reader.ReadBoolean();
FogKeepExp = reader.ReadBoolean();
FogKeepExp2 = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
if (IsReadAlbedoSwatchInfos(reader.Version))
{
m_albedoSwatchInfos = reader.ReadAssetArray <AlbedoSwatchInfo>();
}
}
else
#endif
{
if (IsReadShaderDefinesPerShaderCompiler(reader.Version))
{
m_shaderDefinesPerShaderCompiler = reader.ReadAssetArray <PlatformShaderDefines>();
}
}
if (IsReadLightsUseLinearIntensity(reader.Version))
{
LightsUseLinearIntensity = reader.ReadBoolean();
LightsUseColorTemperature = reader.ReadBoolean();
}
}
public void Read(AssetReader reader)
{
X.Read(reader);
ParentHumanIndex = reader.ReadUInt32();
ID = reader.ReadUInt32();
}
public void Read(AssetReader reader)
{
TransformParent.Read(reader);
Modifications = reader.ReadAssetArray <PropertyModification>();
RemovedComponents = reader.ReadAssetArray <PPtr <Component> >();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
ClearFlags = reader.ReadUInt32();
BackGroundColor.Read(reader);
if (IsReadProjectionMatrixMode(reader.Version))
{
ProjectionMatrixMode = (ProjectionMatrixMode)reader.ReadInt32();
SensorSize.Read(reader);
LensShift.Read(reader);
}
if (IsReadGateFitMode(reader.Version))
{
GateFitMode = (GateFitMode)reader.ReadInt32();
}
if (IsReadFocalLength(reader.Version))
{
FocalLength = reader.ReadSingle();
}
NormalizedViewPortRect.Read(reader);
NearClipPlane = reader.ReadSingle();
FarClipPlane = reader.ReadSingle();
FieldOfView = reader.ReadSingle();
Orthographic = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
OrthographicSize = reader.ReadSingle();
Depth = reader.ReadSingle();
CullingMask.Read(reader);
if (IsReadRenderingPath(reader.Version))
{
RenderingPath = (RenderingPath)reader.ReadInt32();
}
TargetTexture.Read(reader);
if (IsReadTargetDisplay(reader.Version))
{
TargetDisplay = reader.ReadInt32();
}
if (IsReadTargetEye(reader.Version))
{
TargetEye = (StereoTargetEyeMask)reader.ReadInt32();
}
if (IsReadHDR(reader.Version))
{
HDR = reader.ReadBoolean();
}
if (IsReadAllowMSAA(reader.Version))
{
AllowMSAA = reader.ReadBoolean();
}
if (IsReadAllowDynamicResolution(reader.Version))
{
AllowDynamicResolution = reader.ReadBoolean();
}
if (IsReadForceIntoRT(reader.Version))
{
ForceIntoRT = reader.ReadBoolean();
}
if (IsReadOcclusionCulling(reader.Version))
{
OcclusionCulling = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadStereoConvergence(reader.Version))
{
StereoConvergence = reader.ReadSingle();
StereoSeparation = reader.ReadSingle();
}
if (IsReadStereoMirrorMode(reader.Version))
{
StereoMirrorMode = reader.ReadBoolean();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
RenderMode = IsModeShort(reader.Version) ? (ParticleSystemRenderMode)reader.ReadUInt16() : (ParticleSystemRenderMode)reader.ReadInt32();
if (IsSortModeFirst(reader.Version))
{
SortMode = (ParticleSystemSortMode)reader.ReadUInt16();
}
if (HasMinParticleSize(reader.Version))
{
MinParticleSize = reader.ReadSingle();
}
MaxParticleSize = reader.ReadSingle();
CameraVelocityScale = reader.ReadSingle();
VelocityScale = reader.ReadSingle();
LengthScale = reader.ReadSingle();
SortingFudge = reader.ReadSingle();
if (HasNormalDirection(reader.Version))
{
NormalDirection = reader.ReadSingle();
}
if (HasShadowBias(reader.Version))
{
ShadowBias = reader.ReadSingle();
}
if (!IsSortModeFirst(reader.Version))
{
SortMode = (ParticleSystemSortMode)reader.ReadInt32();
}
if (HasRenderAlignment(reader.Version))
{
RenderAlignment = (ParticleSystemRenderSpace)reader.ReadInt32();
Pivot.Read(reader);
}
else
{
RenderAlignment = RenderMode == ParticleSystemRenderMode.Mesh ? ParticleSystemRenderSpace.Local : ParticleSystemRenderSpace.View;
}
if (HasFlip(reader.Version))
{
Flip.Read(reader);
}
if (HasUseCustomVertexStreams(reader.Version))
{
UseCustomVertexStreams = reader.ReadBoolean();
if (HasEnableGPUInstancing(reader.Version))
{
EnableGPUInstancing = reader.ReadBoolean();
}
if (HasApplyActiveColorSpace(reader.Version))
{
ApplyActiveColorSpace = reader.ReadBoolean();
}
if (HasAllowRoll(reader.Version))
{
AllowRoll = reader.ReadBoolean();
}
reader.AlignStream();
}
if (HasVertexStreamMask(reader.Version))
{
int vertexStreamMask = reader.ReadInt32();
List <byte> vertexStreams = new List <byte>(8);
for (byte i = 0; i < 8; i++)
{
if ((vertexStreamMask & (1 << i)) != 0)
{
vertexStreams.Add(i);
}
}
VertexStreams = vertexStreams.ToArray();
}
if (HasVertexStreams(reader.Version))
{
VertexStreams = reader.ReadByteArray();
reader.AlignStream();
}
Mesh.Read(reader);
if (HasMeshes(reader.Version))
{
Mesh1.Read(reader);
Mesh2.Read(reader);
Mesh3.Read(reader);
}
if (HasMaskInteraction(reader.Version))
{
MaskInteraction = (SpriteMaskInteraction)reader.ReadInt32();
}
}
public void Read(AssetReader reader)
{
m_data = reader.ReadAssetArray <SkeletonMaskElement>();
}
public void Read(AssetReader reader)
{
X = reader.ReadInt32();
Y = reader.ReadInt32();
Z = reader.ReadInt32();
}
public void Read(AssetReader reader)
{
m_passes = reader.ReadArray <SerializedPass>();
Tags.Read(reader);
LOD = reader.ReadInt32();
}
public void Read(AssetReader reader)
{
m_tags = new Dictionary <string, string>();
m_tags.Read(reader);
}
public void Read(AssetReader reader)
{
ID = reader.ReadInt32();
}
public void Read(AssetReader reader)
{
DeltaPose.Read(reader);
StartX.Read(reader);
if (HasStopX(reader.Version))
{
StopX.Read(reader);
}
LeftFootStartX.Read(reader);
RightFootStartX.Read(reader);
if (HasMotion(reader.Version))
{
MotionStartX.Read(reader);
MotionStopX.Read(reader);
}
if (IsVector3(reader.Version))
{
AverageSpeed.Read3(reader);
}
else
{
AverageSpeed.Read(reader);
}
Clip.Read(reader);
StartTime = reader.ReadSingle();
StopTime = reader.ReadSingle();
OrientationOffsetY = reader.ReadSingle();
Level = reader.ReadSingle();
CycleOffset = reader.ReadSingle();
AverageAngularSpeed = reader.ReadSingle();
IndexArray = reader.ReadInt32Array();
if (HasAdditionalCurveIndexArray(reader.Version))
{
AdditionalCurveIndexArray = reader.ReadInt32Array();
}
ValueArrayDelta = reader.ReadAssetArray <ValueDelta>();
if (HasValueArrayReferencePose(reader.Version))
{
ValueArrayReferencePose = reader.ReadSingleArray();
}
Mirror = reader.ReadBoolean();
if (HasLoopTime(reader.Version))
{
LoopTime = reader.ReadBoolean();
}
LoopBlend = reader.ReadBoolean();
LoopBlendOrientation = reader.ReadBoolean();
LoopBlendPositionY = reader.ReadBoolean();
LoopBlendPositionXZ = reader.ReadBoolean();
if (HasStartAtOrigin(reader.Version))
{
StartAtOrigin = reader.ReadBoolean();
}
KeepOriginalOrientation = reader.ReadBoolean();
KeepOriginalPositionY = reader.ReadBoolean();
KeepOriginalPositionXZ = reader.ReadBoolean();
HeightFromFeet = reader.ReadBoolean();
reader.AlignStream();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadComponents(reader.Version, reader.Flags))
{
Components = reader.ReadArray <ComponentPair>();
}
if (IsReadIsActiveFirst(reader.Version))
{
IsActive = reader.ReadBoolean();
Layer = reader.ReadUInt32();
Tag = reader.ReadUInt16();
Name = reader.ReadString();
}
else
{
Layer = reader.ReadUInt32();
Name = reader.ReadString();
if (IsReadTag(reader.Flags))
{
Tag = reader.ReadUInt16();
}
#if UNIVERSAL
else
{
TagString = reader.ReadString();
}
if (IsReadIcon(reader.Version, reader.Flags))
{
if (IsReadIconFirst(reader.Version))
{
Icon.Read(reader);
}
}
if (IsReadNavMeshLayer(reader.Version, reader.Flags))
{
NavMeshLayer = reader.ReadUInt32();
StaticEditorFlags = reader.ReadUInt32();
}
#endif
IsActive = reader.ReadBoolean();
#if UNIVERSAL
if (IsReadIsStatic(reader.Version))
{
StaticEditorFlags = reader.ReadBoolean() ? uint.MaxValue : 0;
}
if (IsReadIcon(reader.Version, reader.Flags))
{
if (!IsReadIconFirst(reader.Version))
{
Icon.Read(reader);
}
}
#endif
}
}
public override void Read(AssetReader reader)
{
ReadBase(reader);
#if UNIVERSAL
if (IsReadScript(reader.Version, reader.Flags))
{
Script = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
if (IsReadDefaultProperties(reader.Version, reader.Flags))
{
DefaultProperties.Read(reader);
}
if (IsReadDefaultReferences(reader.Version, reader.Flags))
{
m_defaultReferences = new Dictionary <string, PPtr <Object> >();
m_defaultReferences.Read(reader);
}
if (IsReadIcon(reader.Version, reader.Flags))
{
Icon.Read(reader);
}
if (IsReadEditorGraphData(reader.Version, reader.Flags))
{
EditorGraphData.Read(reader);
}
#endif
if (IsReadExecutionOrder(reader.Version))
{
ExecutionOrder = reader.ReadInt32();
}
if (IsReadPropertiesHash(reader.Version, reader.Flags))
{
if (IsUInt32Hash(reader.Version))
{
uint hash = reader.ReadUInt32();
PropertiesHash = new Hash128(hash);
}
else
{
PropertiesHash.Read(reader);
}
}
if (IsReadPathName(reader.Version))
{
PathName = reader.ReadString();
}
ClassName = reader.ReadString();
if (IsReadNamespace(reader.Version))
{
Namespace = reader.ReadString();
}
if (IsReadAssemblyName(reader.Version, reader.Flags))
{
AssemblyNameOrigin = reader.ReadString();
AssemblyName = FilenameUtils.FixAssemblyName(AssemblyNameOrigin);
}
if (IsReadIsEditorScript(reader.Version))
{
IsEditorScript = reader.ReadBoolean();
}
}
public IEnumerable <PropertyData> LoadData(AssetReader reader, string?parameter)
{
var cats = reader.categories.Where(c => c is NormalCategory {
Data: { }
}).Cast <NormalCategory>();
public void Read(AssetReader reader)
{
Offset = reader.ReadUInt32();
Size = reader.ReadUInt32();
Path = reader.ReadString();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (HasOutputAudioMixerGroup(reader.Version))
{
OutputAudioMixerGroup.Read(reader);
}
AudioClip.Read(reader);
PlayOnAwake = reader.ReadBoolean();
if (IsAlignAwake(reader.Version))
{
reader.AlignStream();
}
Volume = reader.ReadSingle();
if (HasMinVolume(reader.Version))
{
MinVolume = reader.ReadSingle();
MaxVolume = reader.ReadSingle();
}
if (HasPitch(reader.Version))
{
Pitch = reader.ReadSingle();
}
Loop = reader.ReadBoolean();
if (HasRolloffFactor(reader.Version))
{
RolloffFactor = reader.ReadSingle();
}
if (HasMute(reader.Version))
{
Mute = reader.ReadBoolean();
}
if (HasSpatialize(reader.Version))
{
Spatialize = reader.ReadBoolean();
}
if (HasSpatializePostEffects(reader.Version))
{
SpatializePostEffects = reader.ReadBoolean();
}
if (IsAlignMute(reader.Version))
{
reader.AlignStream();
}
if (HasPriority(reader.Version))
{
Priority = reader.ReadInt32();
DopplerLevel = reader.ReadSingle();
MinDistance = reader.ReadSingle();
MaxDistance = reader.ReadSingle();
Pan2D = reader.ReadSingle();
RolloffMode = (AudioRolloffMode)reader.ReadInt32();
BypassEffects = reader.ReadBoolean();
}
if (HasBypassListenerEffects(reader.Version))
{
BypassListenerEffects = reader.ReadBoolean();
BypassReverbZones = reader.ReadBoolean();
}
if (IsAlignBypass(reader.Version))
{
reader.AlignStream();
}
if (HasRolloffCustomCurve(reader.Version))
{
RolloffCustomCurve.Read(reader);
PanLevelCustomCurve.Read(reader);
SpreadCustomCurve.Read(reader);
}
if (HasReverbZoneMixCustomCurve(reader.Version))
{
ReverbZoneMixCustomCurve.Read(reader);
}
}
public void Read(AssetReader reader, string path)
{
Size = reader.ReadUInt32();
Offset = reader.ReadUInt32();
Path = path;
}
public void Read(AssetReader reader)
{
ParentId = reader.ReadInt32();
AxesId = reader.ReadInt32();
}
public void Read(AssetReader reader)
{
m_channels = reader.ReadArray <ShaderBindChannel>();
reader.AlignStream(AlignType.Align4);
SourceMap = reader.ReadInt32();
}
public object LoadAsset(AssetReader input)
{
return new TmxMap(input.BaseStream);
}
public override void Read(AssetReader reader)
{
throw new NotSupportedException();
}
