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();
}
AssemblyName = stream.ReadStringAligned();
if (IsReadIsEditorScript(stream.Version))
{
IsEditorScript = stream.ReadBoolean();
}
}
public void Read(AssetStream stream)
{
if (IsReadBlendType(stream.Version))
{
BlendType = stream.ReadUInt32();
}
BlendEventID = stream.ReadUInt32();
if (IsReadBlendEventYID(stream.Version))
{
BlendEventYID = stream.ReadUInt32();
}
m_childIndices = stream.ReadUInt32Array();
if (IsReadChildThresholdArray(stream.Version))
{
m_childThresholdArray = stream.ReadSingleArray();
}
if (IsReadBlendData(stream.Version))
{
Blend1dData.Read(stream);
Blend2dData.Read(stream);
}
if (IsReadBlendDirectData(stream.Version))
{
BlendDirectData.Read(stream);
}
ClipID = stream.ReadUInt32();
if (IsReadClipIndex(stream.Version))
{
ClipIndex = stream.ReadUInt32();
}
Duration = stream.ReadSingle();
if (IsReadCycleOffset(stream.Version))
{
CycleOffset = stream.ReadSingle();
Mirror = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Resolution = stream.ReadSingle();
ClusterResolution = stream.ReadSingle();
IrradianceBudget = stream.ReadInt32();
IrradianceQuality = stream.ReadInt32();
BackFaceTolerance = stream.ReadSingle();
IsTransparent = stream.ReadInt32();
ModellingTolerance = stream.ReadSingle();
SystemTag = stream.ReadInt32();
EdgeStitching = stream.ReadInt32();
BlurRadius = stream.ReadInt32();
DirectLightQuality = stream.ReadInt32();
AntiAliasingSamples = stream.ReadInt32();
BakedLightmapTag = stream.ReadInt32();
Pushoff = stream.ReadSingle();
AOQuality = stream.ReadInt32();
AOAntiAliasingSamples = stream.ReadInt32();
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadSpriteTilingProperty(stream.Version))
{
SpriteTilingProperty.Read(stream);
AutoTiling = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
Size.Read(stream);
if (IsReadCenter(stream.Version))
{
Center.Read(stream);
}
if (IsReadEdgeRadius(stream.Version))
{
EdgeRadius = stream.ReadSingle();
}
}
/// <summary>
/// Return list of key path to changed content file.
/// </summary>
/// <returns></returns>
public IEnumerable <string> GetRemovedDependencies()
{
var removedDeps = new List <string>();
if (!TargetFileExists)
{
throw new InvalidOperationException("Target file does not exist");
}
using (var assetStream = AssetStream.OpenRead(FullTargetPath)) {
foreach (var dependency in assetStream.Dependencies)
{
if (!context.ContentFileExists(dependency))
{
removedDeps.Add(dependency);
}
}
}
return(removedDeps);
}
public void Read(AssetStream stream)
{
FirstByte = (int)stream.ReadUInt32();
IndexCount = (int)stream.ReadUInt32();
Topology = (MeshTopology)stream.ReadUInt32();
if (IsReadTriangleCount(stream.Version))
{
TriangleCount = (int)stream.ReadUInt32();
}
if (IsReadBaseVertex(stream.Version))
{
BaseVertex = stream.ReadUInt32();
}
if (IsReadVertex(stream.Version))
{
FirstVertex = stream.ReadUInt32();
VertexCount = stream.ReadUInt32();
LocalAABB.Read(stream);
}
}
public void Read(AssetStream stream)
{
Texture.Read(stream);
if (IsReadNormalMap(stream.Version))
{
NormalMap.Read(stream);
}
TileSize.Read(stream);
if (IsReadTileOffset(stream.Version))
{
TileOffset.Read(stream);
}
if (IsReadSpecularMetallic(stream.Version))
{
SpecularMetallic.Read(stream);
}
if (IsReadSmoothness(stream.Version))
{
Smoothness = stream.ReadSingle();
}
}
/*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)
{
m_groups = stream.ReadArray <GroupConstant>();
m_groupGUIDs = stream.ReadArray <UtinyGUID>();
m_effects = stream.ReadArray <EffectConstant>();
m_effectGUIDs = stream.ReadArray <UtinyGUID>();
NumSideChainBuffers = stream.ReadUInt32();
m_snapshots = stream.ReadArray <SnapshotConstant>();
m_snapshotGUIDs = stream.ReadArray <UtinyGUID>();
//m_groupNameBuffer = stream.ReadArray<char>();
stream.AlignStream(AlignType.Align4);
//m_snapshotNameBuffer = stream.ReadArray<char>();
stream.AlignStream(AlignType.Align4);
//m_pluginEffectNameBuffer = stream.ReadArray<char>();
stream.AlignStream(AlignType.Align4);
m_exposedParameterNames = stream.ReadUInt32Array();
m_exposedParameterIndices = stream.ReadUInt32Array();
}
public void Read(AssetStream stream)
{
if (IsReadChannels(stream.Version))
{
m_vertices = stream.ReadArray <BlendShapeVertex>();
m_shapes = stream.ReadArray <BlendShape>();
m_channels = stream.ReadArray <BlendShapeChannel>();
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
m_fullWeights = stream.ReadSingleArray();
}
else
{
m_shapes = stream.ReadArray <BlendShape>();
stream.AlignStream(AlignType.Align4);
m_vertices = stream.ReadArray <BlendShapeVertex>();
}
}
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(AssetStream stream)
{
Path = stream.ReadUInt32();
Attribute = stream.ReadUInt32();
Script.Read(stream);
if (IsInt32ID(stream.Version))
{
ClassID = (ClassIDType)stream.ReadInt32();
}
else
{
ClassID = (ClassIDType)stream.ReadUInt16();
}
CustomType = stream.ReadByte();
IsPPtrCurve = stream.ReadByte();
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
m_tags = stream.ReadStringArray();
if (IsReadStaticArray(stream.Version))
{
m_layers = new string[32];
for (int i = 0; i < m_layers.Length; i++)
{
m_layers[i] = stream.ReadStringAligned();
}
}
else
{
m_layers = stream.ReadStringArray();
}
if (IsReadSortingLayers(stream.Version))
{
m_sortingLayers = stream.ReadArray <SortingLayerEntry>();
}
}
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 (IsReadMultiThreadedStateMachine(stream.Version))
{
MultiThreadedStateMachine = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
m_patches = stream.ReadArray <DetailPatch>();
m_detailPrototypes = stream.ReadArray <DetailPrototype>();
PatchCount = stream.ReadInt32();
PatchSamples = stream.ReadInt32();
m_randomRotations = stream.ReadArray <Vector3f>();
if (IsReadAtlasTexture(stream.Version))
{
AtlasTexture.Read(stream);
}
WavingGrassTint.Read(stream);
WavingGrassStrength = stream.ReadSingle();
WavingGrassAmount = stream.ReadSingle();
WavingGrassSpeed = stream.ReadSingle();
m_treeInstances = stream.ReadArray <TreeInstance>();
m_treePrototypes = stream.ReadArray <TreePrototype>();
if (IsReadPreloadTextureAtlasData(stream.Version))
{
m_preloadTextureAtlasData = stream.ReadArray <PPtr <Texture2D> >();
}
}
private void ReadAsset(AssetStream stream, ObjectInfo info, long startPosition)
{
AssetInfo assetInfo;
if (ObjectInfo.IsReadTypeIndex(Header.Generation))
{
RTTIBaseClassDescriptor typemeta = Metadata.Hierarchy.Types[info.TypeIndex];
assetInfo = new AssetInfo(this, info.PathID, typemeta.ClassID);
}
else
{
assetInfo = new AssetInfo(this, info.PathID, info.ClassID);
}
long pathID = info.PathID;
Object asset = ReadAsset(stream, assetInfo, startPosition + Header.DataOffset + info.DataOffset, info.DataSize);
if (asset != null)
{
AddAsset(pathID, asset);
}
}
public void Read(AssetStream stream)
{
if (IsMinMaxStateFirst(stream.Version))
{
MinMaxState = (ParticleSystemCurveMode)stream.ReadUInt16();
stream.AlignStream(AlignType.Align4);
}
Scalar = stream.ReadSingle();
if (IsReadMinScalar(stream.Version))
{
MinScalar = stream.ReadSingle();
}
MaxCurve.Read(stream);
MinCurve.Read(stream);
if (!IsMinMaxStateFirst(stream.Version))
{
MinMaxState = (ParticleSystemCurveMode)stream.ReadUInt16();
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
DynamicFriction = stream.ReadSingle();
StaticFriction = stream.ReadSingle();
Bounciness = stream.ReadSingle();
FrictionCombine = stream.ReadInt32();
BounceCombine = stream.ReadInt32();
if (IsReadFrictionDirection2(stream.Version))
{
FrictionDirection2.Read(stream);
DynamicFriction2 = stream.ReadSingle();
StaticFriction2 = stream.ReadSingle();
}
if (IsReadUseSpring(stream.Version))
{
UseSpring = stream.ReadBoolean();
Spring.Read(stream);
}
}
public void Read(AssetStream stream)
{
Texture.Read(stream);
if (IsReadAlphaTexture(stream.Version))
{
AlphaTexture.Read(stream);
}
if (IsReadVertices(stream.Version))
{
m_vertices = stream.ReadArray <SpriteVertex>();
m_indices = stream.ReadUInt16Array();
stream.AlignStream(AlignType.Align4);
}
else
{
m_subMeshes = stream.ReadArray <SubMesh>();
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
VertexData.Read(stream);
}
TextureRect.Read(stream);
TextureRectOffset.Read(stream);
if (IsReadAtlasRectOffset(stream.Version))
{
AtlasRectOffset.Read(stream);
}
SettingsRaw = stream.ReadUInt32();
if (IsReadUVTransform(stream.Version))
{
UVTransform.Read(stream);
}
if (IsReadDownscaleMultiplier(stream.Version))
{
DownscaleMultiplier = stream.ReadSingle();
}
}
public static void AppendInboundChunk(SessionState sessionState, AssetStream chunk)
{
AssetState entry;
if (inboundQueue.ContainsKey(chunk.assetRec.propSpec.id))
{
entry = inboundQueue[chunk.assetRec.propSpec.id];
}
else
{
entry = new AssetState
{
sessionState = sessionState,
assetStream = chunk,
};
inboundQueue[chunk.assetRec.propSpec.id] = entry;
}
if (entry.sessionState.driver.IsConnected() && entry.assetStream.hasData && entry.sessionState.UserID == sessionState.UserID)
{
entry.assetStream.CopyChunkData(chunk);
entry.assetStream.assetRec.blockNbr++;
}
if (entry.assetStream.assetRec.blockNbr == entry.assetStream.assetRec.nbrBlocks)
{
entry.assetStream.Write();
}
if (!entry.sessionState.driver.IsConnected() || !entry.assetStream.hasData || entry.assetStream.assetRec.blockNbr == entry.assetStream.assetRec.nbrBlocks)
{
entry.assetStream.Dispose();
inboundQueue.Remove(entry.assetStream.assetRec.propSpec.id);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadMeshFirst(stream.Version))
{
Mesh.Read(stream);
}
if (IsReadSmoothSphereCollisions(stream.Version))
{
SmoothSphereCollisions = stream.ReadBoolean();
}
Convex = stream.ReadBoolean();
if (IsReadInflateMesh(stream.Version))
{
InflateMesh = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadCookingOptions(stream.Version))
{
CookingOptions = (MeshColliderCookingOptions)stream.ReadInt32();
stream.AlignStream(AlignType.Align4);
}
if (IsReadSkinWidth(stream.Version))
{
SkinWidth = stream.ReadSingle();
}
if (!IsReadMeshFirst(stream.Version))
{
Mesh.Read(stream);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Sprite.Read(stream);
Color.Read(stream);
if (IsAlignColor(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadFlip(stream.Version))
{
FlipX = stream.ReadBoolean();
FlipY = stream.ReadBoolean();
if (IsAlignFlip(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadDrawMode(stream.Version))
{
DrawMode = (SpriteDrawMode)stream.ReadInt32();
Size.Read(stream);
AdaptiveModeThreshold = stream.ReadSingle();
SpriteTileMode = (SpriteTileMode)stream.ReadInt32();
}
if (IsReadWasSpriteAssigned(stream.Version))
{
WasSpriteAssigned = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
if (IsReadMaskInteraction(stream.Version))
{
MaskInteraction = (SpriteMaskInteraction)stream.ReadInt32();
}
}
public void Read(AssetStream stream)
{
if (IsReadIndex(stream.Version))
{
Index = stream.ReadInt32();
}
UV.Read(stream);
Vert.Read(stream);
if (IsReadWidth(stream.Version))
{
Width = stream.ReadSingle();
}
if (IsReadAdvance(stream.Version))
{
Advance = stream.ReadSingle();
}
if (IsReadFlipped(stream.Version))
{
Flipped = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadPVSData(stream.Version))
{
m_PVSData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
if (IsReadQueryMode(stream.Version))
{
QueryMode = stream.ReadInt32();
}
m_staticRenderers = stream.ReadArray <PPtr <Renderer> >();
m_portals = stream.ReadArray <PPtr <OcclusionPortal> >();
if (IsReadOcclusionBakeSettings(stream.Flags))
{
OcclusionBakeSettings.Read(stream);
}
}
else
{
if (IsReadOcclusionBakeSettings(stream.Flags))
{
OcclusionBakeSettings.Read(stream);
}
SceneGUID.Read(stream);
OcclusionCullingData.Read(stream);
if (IsReadStaticRenderers(stream.Version, stream.Flags))
{
m_staticRenderers = stream.ReadArray <PPtr <Renderer> >();
m_portals = stream.ReadArray <PPtr <OcclusionPortal> >();
}
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
m_scripts = stream.ReadArray <PPtr <MonoScript> >();
if (IsReadHasCompileErrors(stream.Version))
{
HasCompileErrors = stream.ReadBoolean();
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 void Read(AssetStream stream)
{
AvatarSkeleton.Read(stream);
AvatarSkeletonPose.Read(stream);
if (IsReadDefaultPose(stream.Version))
{
DefaultPose.Read(stream);
m_skeletonNameIDArray = stream.ReadUInt32Array();
}
Human.Read(stream);
m_humanSkeletonIndexArray = stream.ReadInt32Array();
if (IsReadHumanSkeletonReverseIndexArray(stream.Version))
{
m_humanSkeletonReverseIndexArray = stream.ReadInt32Array();
}
RootMotionBoneIndex = stream.ReadInt32();
RootMotionBoneX.Read(stream);
if (IsReadRootMotionSkeleton(stream.Version))
{
RootMotionSkeleton.Read(stream);
RootMotionSkeletonPose.Read(stream);
m_rootMotionSkeletonIndexArray = stream.ReadInt32Array();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
m_navMeshTiles = stream.ReadArray <NavMeshTileData>();
if (IsReadNavMeshParams(stream.Version))
{
NavMeshParams.Read(stream);
}
else
{
NavMeshBuildSettings.Read(stream);
}
m_heightmaps = stream.ReadArray <HeightmapData>();
m_heightMeshes = stream.ReadArray <HeightMeshData>();
m_offMeshLinks = stream.ReadArray <AutoOffMeshLinkData>();
if (IsReadSourceBounds(stream.Version))
{
SourceBounds.Read(stream);
Rotation.Read(stream);
Position.Read(stream);
AgentTypeID = stream.ReadInt32();
}
}
public void Read(AssetStream stream)
{
long startPosition = stream.BaseStream.Position;
int count = stream.ReadInt32();
long headerPosition = stream.BaseStream.Position;
m_subPrograms = new ShaderSubProgram[count];
for (int i = 0; i < count; i++)
{
stream.BaseStream.Position = headerPosition + i * 8;
int offset = stream.ReadInt32();
int length = stream.ReadInt32();
long dataPosition = startPosition + offset;
stream.BaseStream.Position = dataPosition;
ShaderSubProgram subProgram = new ShaderSubProgram();
subProgram.Read(stream);
if (stream.BaseStream.Position != dataPosition + length)
{
throw new Exception($"Read less {stream.BaseStream.Position - dataPosition} than expected {length}");
}
m_subPrograms[i] = subProgram;
}
}
public void Read(AssetStream stream)
{
Type = (LightShadows)stream.ReadInt32();
Resolution = stream.ReadInt32();
if (IsReadCustomResolution(stream.Version))
{
CustomResolution = stream.ReadInt32();
}
Strength = stream.ReadSingle();
if (IsReadProjection(stream.Version))
{
Projection = stream.ReadInt32();
}
if (IsReadConstantBias(stream.Version))
{
ConstantBias = stream.ReadSingle();
ObjectSizeBias = stream.ReadSingle();
}
if (IsReadBias(stream.Version))
{
Bias = stream.ReadSingle();
}
if (IsReadSoftness(stream.Version))
{
Softness = stream.ReadSingle();
SoftnessFade = stream.ReadSingle();
}
if (IsReadNormalBias(stream.Version))
{
NormalBias = stream.ReadSingle();
}
if (IsReadNearPlane(stream.Version))
{
NearPlane = stream.ReadSingle();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
X.Read(stream);
Y.Read(stream);
Z.Read(stream);
if (IsReadOrbital(stream.Version))
{
OrbitalX.Read(stream);
OrbitalY.Read(stream);
OrbitalZ.Read(stream);
OrbitalOffsetX.Read(stream);
OrbitalOffsetY.Read(stream);
OrbitalOffsetZ.Read(stream);
Radial.Read(stream);
}
if (IsReadSpeedModifier(stream.Version))
{
SpeedModifier.Read(stream);
}
InWorldSpace = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
Bits = Is16Bits(stream.Version) ? stream.ReadUInt16() : stream.ReadUInt32();
}
