public override void Read(AssetReader reader)
{
base.Read(reader);
ConnectedBody.Read(reader);
Anchor = reader.ReadAsset <Vector3f>();
Axis = reader.ReadAsset <Vector3f>();
AutoConfigureConnectedAnchor = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
ConnectedAnchor = reader.ReadAsset <Vector3f>();
SwingAxis = reader.ReadAsset <Vector3f>();
TwistLimitSpring = reader.ReadAsset <SoftJointLimitSpring>();
LowTwistLimit = reader.ReadAsset <SoftJointLimit>();
HighTwistLimit = reader.ReadAsset <SoftJointLimit>();
SwingLimitSpring = reader.ReadAsset <SoftJointLimitSpring>();
Swing1Limit = reader.ReadAsset <SoftJointLimit>();
Swing2Limit = reader.ReadAsset <SoftJointLimit>();
EnableProjection = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
ProjectionDistance = reader.ReadSingle();
ProjectionAngle = reader.ReadSingle();
BreakForce = reader.ReadSingle();
BreakTorque = reader.ReadSingle();
EnableCollision = reader.ReadBoolean();
EnablePreprocessing = reader.ReadBoolean();
if (IsReadMassScale(reader.Version))
{
reader.AlignStream(AlignType.Align4);
MassScale = reader.ReadSingle();
ConnectedMassScale = reader.ReadSingle();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
ConnectedBody.Read(reader);
Anchor = reader.ReadAsset <Vector3f>();
AutoConfigureConnectedAnchor = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
ConnectedAnchor = reader.ReadAsset <Vector3f>();
Spring = reader.ReadSingle();
Damper = reader.ReadSingle();
MinDistance = reader.ReadSingle();
MaxDistance = reader.ReadSingle();
Tolerance = reader.ReadSingle();
BreakForce = reader.ReadSingle();
BreakTorque = reader.ReadSingle();
EnableCollision = reader.ReadBoolean();
EnablePreprocessing = reader.ReadBoolean();
if (IsReadMassScale(reader.Version))
{
reader.AlignStream(AlignType.Align4);
MassScale = reader.ReadSingle();
ConnectedMassScale = reader.ReadSingle();
}
}
public void Read(AssetReader reader)
{
if (IsMaxGradientFirst(reader.Version))
{
MaxGradient.Read(reader);
MinGradient.Read(reader);
if (IsColor32(reader.Version))
{
MinColor32 = reader.ReadAsset <ColorRGBA32>();
MaxColor32 = reader.ReadAsset <ColorRGBA32>();
}
else
{
MinColor.Read(reader);
MaxColor.Read(reader);
}
}
MinMaxState = (MinMaxGradientState)reader.ReadUInt16();
reader.AlignStream();
if (!IsMaxGradientFirst(reader.Version))
{
MinColor.Read(reader);
MaxColor.Read(reader);
MaxGradient.Read(reader);
MinGradient.Read(reader);
}
}
public void Read(AssetReader reader)
{
if (IsVector3(reader.Version))
{
Min = reader.ReadAsset <Vector3f>();
Max = reader.ReadAsset <Vector3f>();
}
else
{
Min4.Read(reader);
Max4.Read(reader);
}
}
private static void FindMinMaxBounds(Version version, ref VertexData vertexData, int firstVertex, int vertexCount, out Vector3f min, out Vector3f max)
{
ChannelInfo channel = vertexData.GetChannel(version, ShaderChannel.Vertex);
int streamOffset = vertexData.GetStreamOffset(version, channel.Stream);
int streamStride = vertexData.GetStreamStride(version, channel.Stream);
int extraStride = streamStride - ShaderChannel.Vertex.GetStride(version);
int vertexOffset = firstVertex * streamStride;
int begin = streamOffset + vertexOffset + channel.Offset;
using (MemoryStream stream = new MemoryStream(vertexData.Data))
{
using (AssetReader reader = new AssetReader(stream, version, Platform.NoTarget, TransferInstructionFlags.NoTransferInstructionFlags))
{
stream.Position = begin;
Vector3f dummyVertex = reader.ReadAsset <Vector3f>();
min = dummyVertex;
max = dummyVertex;
stream.Position = begin;
for (int i = 0; i < vertexCount; i++)
{
Vector3f vertex = reader.ReadAsset <Vector3f>();
if (vertex.X > max.X)
{
max.X = vertex.X;
}
else if (vertex.X < min.X)
{
min.X = vertex.X;
}
if (vertex.Y > max.Y)
{
max.Y = vertex.Y;
}
else if (vertex.Y < min.Y)
{
min.Y = vertex.Y;
}
if (vertex.Z > max.Z)
{
max.Z = vertex.Z;
}
else if (vertex.Z < min.Z)
{
min.Z = vertex.Z;
}
stream.Position += extraStride;
}
}
}
}
private static void FindMinMaxBounds(AssetLayout layout, ref VertexData vertexData, int firstVertex, int vertexCount, out Vector3f min, out Vector3f max)
{
ChannelInfo channel = vertexData.GetChannel(layout.Info.Version, ShaderChannel.Vertex);
int streamOffset = vertexData.GetStreamOffset(layout.Info.Version, channel.Stream);
int streamStride = vertexData.GetStreamStride(layout.Info.Version, channel.Stream);
int extraStride = streamStride - ShaderChannel.Vertex.GetStride(layout.Info.Version);
int vertexOffset = firstVertex * streamStride;
int begin = streamOffset + vertexOffset + channel.Offset;
using (MemoryStream stream = new MemoryStream(vertexData.Data))
{
using (AssetReader reader = new AssetReader(stream, EndianType.LittleEndian, layout))
{
stream.Position = begin;
Vector3f dummyVertex = reader.ReadAsset <Vector3f>();
min = dummyVertex;
max = dummyVertex;
stream.Position = begin;
for (int i = 0; i < vertexCount; i++)
{
Vector3f vertex = reader.ReadAsset <Vector3f>();
if (vertex.X > max.X)
{
max.X = vertex.X;
}
else if (vertex.X < min.X)
{
min.X = vertex.X;
}
if (vertex.Y > max.Y)
{
max.Y = vertex.Y;
}
else if (vertex.Y < min.Y)
{
min.Y = vertex.Y;
}
if (vertex.Z > max.Z)
{
max.Z = vertex.Z;
}
else if (vertex.Z < min.Z)
{
min.Z = vertex.Z;
}
stream.Position += extraStride;
}
}
}
}
public void Read(AssetReader reader)
{
Texture.Read(reader);
if (IsVector3(reader.Version))
{
Scale3.Read(reader);
Offset3.Read(reader);
}
else
{
Scale = reader.ReadAsset <Vector2f>();
Offset = reader.ReadAsset <Vector2f>();
}
}
public void Read(AssetReader reader)
{
if (IsReadBuildTargetString(reader.Version))
{
string buildTarget = reader.ReadString();
BuildTarget = StringToBuildGroup(buildTarget);
}
else
{
BuildTarget = (BuildTargetGroup)reader.ReadInt32();
}
if (IsReadTier(reader.Version))
{
Tier = (GraphicsTier)reader.ReadInt32();
}
if (IsReadPlatfromSettings(reader.Version))
{
PlatformShaderSettings settings = reader.ReadAsset <PlatformShaderSettings>();
Settings = new TierGraphicsSettingsEditor(settings, reader.Version, reader.Flags);
}
else
{
Settings.Read(reader);
}
Automatic = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
if (HasCurrentChannels(reader.Version))
{
CurrentChannels = reader.ReadUInt32();
}
VertexCount = (int)reader.ReadUInt32();
if (HasChannels(reader.Version))
{
Channels = reader.ReadAssetArray <ChannelInfo>();
reader.AlignStream(AlignType.Align4);
}
if (HasStreams(reader.Version))
{
if (IsStreamStatic(reader.Version))
{
Streams = new StreamInfo[StaticStreamCount];
for (int i = 0; i < StaticStreamCount; i++)
{
Streams[i] = reader.ReadAsset <StreamInfo>();
}
}
else
{
Streams = reader.ReadAssetArray <StreamInfo>();
}
}
Data = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
RootX.Read(reader);
if (IsVector3(reader.Version))
{
LookAtPosition = reader.ReadAsset <Vector3f>();
}
else
{
LookAtPosition.Read(reader);
}
LookAtWeight.Read(reader);
GoalArray = reader.ReadAssetArray <HumanGoal>();
LeftHandPose.Read(reader);
RightHandPose.Read(reader);
DoFArray = reader.ReadSingleArray();
if (HasTArray(reader.Version))
{
if (IsVector3(reader.Version))
{
TDoFArray = reader.ReadVector3Array();
}
else
{
TDoFArray = reader.ReadAssetArray <Vector4f>();
}
}
}
public void CanSerializeTreeCollection()
{
var entity0 = new Entity(new VariableCollection());
var entity1 = new Entity(new VariableCollection());
var entity2 = new Entity(new VariableCollection());
var entity3 = new Entity(new VariableCollection());
entity1.Parent = entity0;
entity2.Parent = entity0;
entity3.Parent = entity1;
entity0.AddComponent <FakeComp>();
entity1.AddComponent <FakeComp>();
entity1.AddComponent <FakeComp>();
entity2.AddComponent <FakeComp>();
entity3.AddComponent <FakeComp>();
collection.Add(entity0);
Stream stream = new MemoryStream();
AssetWriter.WriteAsset(stream, collection, new TypeWriterFactory());
stream.Position = 0;
var collection2 = AssetReader.ReadAsset <EntityCollection>(stream, new TypeReaderFactory());
}
public void CanSerializeValidTypes([ValueSource("Values")] object value)
{
var stream = new System.IO.MemoryStream();
AssetWriter.WriteAsset(stream, value, new TypeWriterFactory());
stream.Position = 0;
object result = AssetReader.ReadAsset <object>(stream, new TypeReaderFactory());
Assert.AreEqual(value, result);
}
public void Read(AssetReader reader)
{
GradientLayout layout = reader.Layout.Serialized.Gradient;
if (layout.Version == 1)
{
Key0_32 = reader.ReadAsset <ColorRGBA32>();
Key1_32 = reader.ReadAsset <ColorRGBA32>();
Key2_32 = reader.ReadAsset <ColorRGBA32>();
Key3_32 = reader.ReadAsset <ColorRGBA32>();
Key4_32 = reader.ReadAsset <ColorRGBA32>();
Key5_32 = reader.ReadAsset <ColorRGBA32>();
Key6_32 = reader.ReadAsset <ColorRGBA32>();
Key7_32 = reader.ReadAsset <ColorRGBA32>();
}
else
{
Key0.Read(reader);
Key1.Read(reader);
Key2.Read(reader);
Key3.Read(reader);
Key4.Read(reader);
Key5.Read(reader);
Key6.Read(reader);
Key7.Read(reader);
}
Ctime0 = reader.ReadUInt16();
Ctime1 = reader.ReadUInt16();
Ctime2 = reader.ReadUInt16();
Ctime3 = reader.ReadUInt16();
Ctime4 = reader.ReadUInt16();
Ctime5 = reader.ReadUInt16();
Ctime6 = reader.ReadUInt16();
Ctime7 = reader.ReadUInt16();
Atime0 = reader.ReadUInt16();
Atime1 = reader.ReadUInt16();
Atime2 = reader.ReadUInt16();
Atime3 = reader.ReadUInt16();
Atime4 = reader.ReadUInt16();
Atime5 = reader.ReadUInt16();
Atime6 = reader.ReadUInt16();
Atime7 = reader.ReadUInt16();
if (layout.HasMode)
{
Mode = (GradientMode)reader.ReadInt32();
}
NumColorKeys = reader.ReadByte();
NumAlphaKeys = reader.ReadByte();
reader.AlignStream();
}
public void CanSerializeSignedBytes([Random(sbyte.MinValue, sbyte.MaxValue, 5)] int val)
{
this.writerProviderMock.Setup((w) => w.GetTypeWriter(typeof(sbyte))).Returns(new SignedByteWriter());
this.readerProviderMock.Setup((w) => w.GetTypeReader(typeof(sbyte))).Returns(new SignedByteReader());
AssetWriter.WriteAsset(this.stream, (sbyte)val, this.writerProviderMock.Object);
this.stream.Position = 0;
var result = AssetReader.ReadAsset <sbyte>(stream, this.readerProviderMock.Object);
Assert.AreEqual((sbyte)val, result);
}
public void CanSerializeCharacters([Random(char.MinValue, char.MaxValue, 5)] int val)
{
this.writerProviderMock.Setup((w) => w.GetTypeWriter(typeof(char))).Returns(new CharacterWriter());
this.readerProviderMock.Setup((w) => w.GetTypeReader(typeof(char))).Returns(new CharacterReader());
AssetWriter.WriteAsset(this.stream, (char)val, this.writerProviderMock.Object);
this.stream.Position = 0;
var result = AssetReader.ReadAsset <char>(stream, this.readerProviderMock.Object);
Assert.AreEqual((char)val, result);
}
public void Read(AssetReader reader)
{
if (IsVector3(reader.Version))
{
T = reader.ReadAsset <Vector3f>();
}
else
{
T4.Read(reader);
}
Q.Read(reader);
if (IsVector3(reader.Version))
{
S = reader.ReadAsset <Vector3f>();
}
else
{
S4.Read(reader);
}
}
public static Vector4f[] ReadVector3Array(this AssetReader reader)
{
int count = reader.ReadInt32();
Vector4f[] array = new Vector4f[count];
for (int i = 0; i < count; i++)
{
array[i] = reader.ReadAsset <Vector3f>();
}
return(array);
}
public void CanSerializeDoubles([Random(double.MinValue, double.MaxValue, 5)] double val)
{
this.writerProviderMock.Setup((w) => w.GetTypeWriter(typeof(double))).Returns(new DoubleWriter());
this.readerProviderMock.Setup((w) => w.GetTypeReader(typeof(double))).Returns(new DoubleReader());
AssetWriter.WriteAsset(this.stream, (double)val, this.writerProviderMock.Object);
this.stream.Position = 0;
var result = AssetReader.ReadAsset <double>(stream, this.readerProviderMock.Object);
Assert.AreEqual((double)val, result);
}
public void CanSerializeUnsignedIntegers([Random(uint.MinValue, uint.MaxValue, 5)] double val)
{
this.writerProviderMock.Setup((w) => w.GetTypeWriter(typeof(uint))).Returns(new UInt32Writer());
this.readerProviderMock.Setup((w) => w.GetTypeReader(typeof(uint))).Returns(new UInt32Reader());
AssetWriter.WriteAsset(this.stream, (uint)val, this.writerProviderMock.Object);
this.stream.Position = 0;
var result = AssetReader.ReadAsset <uint>(stream, this.readerProviderMock.Object);
Assert.AreEqual((uint)val, result);
}
public void CanSerializeSignedLongs([Random(long.MinValue, long.MaxValue, 5)] double val)
{
this.writerProviderMock.Setup((w) => w.GetTypeWriter(typeof(long))).Returns(new Int64Writer());
this.readerProviderMock.Setup((w) => w.GetTypeReader(typeof(long))).Returns(new Int64Reader());
AssetWriter.WriteAsset(this.stream, (long)val, this.writerProviderMock.Object);
this.stream.Position = 0;
var result = AssetReader.ReadAsset <long>(stream, this.readerProviderMock.Object);
Assert.AreEqual((long)val, result);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadSubEmitters(reader.Version))
{
m_subEmitters = reader.ReadAssetArray <SubEmitterData>();
}
else
{
List <SubEmitterData> subEmitters = new List <SubEmitterData>();
PPtr <ParticleSystem> subEmitterBirth = reader.ReadAsset <PPtr <ParticleSystem> >();
if (!subEmitterBirth.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Birth, subEmitterBirth));
}
if (IsReadSecond(reader.Version))
{
PPtr <ParticleSystem> subEmitterBirth1 = reader.ReadAsset <PPtr <ParticleSystem> >();
if (!subEmitterBirth1.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Birth, subEmitterBirth1));
}
}
PPtr <ParticleSystem> subEmitterDeath = reader.ReadAsset <PPtr <ParticleSystem> >();
if (!subEmitterDeath.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Death, subEmitterDeath));
}
if (IsReadSecond(reader.Version))
{
PPtr <ParticleSystem> subEmitterDeath1 = reader.ReadAsset <PPtr <ParticleSystem> >();
if (!subEmitterDeath1.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Death, subEmitterDeath1));
}
}
PPtr <ParticleSystem> subEmitterCollision = reader.ReadAsset <PPtr <ParticleSystem> >();
if (!subEmitterCollision.IsNull)
{
subEmitters.Add(new SubEmitterData(ParticleSystemSubEmitterType.Collision, subEmitterCollision));
}
if (IsReadSecond(reader.Version))
{
PPtr <ParticleSystem> subEmitterCollision1 = reader.ReadAsset <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 override void Read(AssetReader reader)
{
base.Read(reader);
ConnectedBody.Read(reader);
Anchor = reader.ReadAsset <Vector3f>();
Axis = reader.ReadAsset <Vector3f>();
AutoConfigureConnectedAnchor = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
ConnectedAnchor = reader.ReadAsset <Vector3f>();
UseSpring = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
Spring = reader.ReadAsset <JointSpring>();
UseMotor = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
Motor = reader.ReadAsset <JointMotor>();
UseLimits = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
Limits = reader.ReadAsset <JointLimits>();
BreakForce = reader.ReadSingle();
BreakTorque = reader.ReadSingle();
EnableCollision = reader.ReadBoolean();
if (IsReadMassScale(reader.Version))
{
reader.AlignStream(AlignType.Align4);
MassScale = reader.ReadSingle();
ConnectedMassScale = reader.ReadSingle();
}
}
public void Read(AssetReader reader)
{
int maxGradientPlacement = GetMaxGradientPlacement(reader.Version);
if (maxGradientPlacement == 1)
{
MaxGradient.Read(reader);
MinGradient.Read(reader);
if (IsColor32(reader.Version))
{
MinColor32 = reader.ReadAsset <ColorRGBA32>();
MaxColor32 = reader.ReadAsset <ColorRGBA32>();
}
else
{
MinColor.Read(reader);
MaxColor.Read(reader);
}
}
// Int16 before 5.6.0p4
MinMaxState = (MinMaxGradientState)reader.ReadUInt16();
reader.AlignStream();
if (maxGradientPlacement != 1)
{
if (maxGradientPlacement == 2)
{
MaxGradient.Read(reader);
MinGradient.Read(reader);
}
MinColor.Read(reader);
MaxColor.Read(reader);
if (maxGradientPlacement == 3)
{
MaxGradient.Read(reader);
MinGradient.Read(reader);
}
}
}
public void CanSerializeSimple()
{
this.entity.Name = "Daniel";
this.entity.AddVar <string>("Bear", "Dancing in the forest of mordor is a weak cat!");
Stream memstream = new MemoryStream();
AssetWriter.WriteAsset(memstream, entity, new TypeWriterFactory());
memstream.Position = 0;
var entity2 = AssetReader.ReadAsset <Entity>(memstream, new TypeReaderFactory());
Assert.AreEqual(entity.Name, entity2.Name);
Assert.AreEqual(entity.GetVar <string>("Bear"), entity2.GetVar <string>("Bear"));
}
private T LoadAssetAsset <T>(string filePath, string assetPath)
{
if (filePath != assetPath)
{
File.Copy(filePath, assetPath, true);
}
T result;
using (Stream stream = new FileStream(assetPath, FileMode.Open))
{
result = AssetReader.ReadAsset <T>(stream, this.trfactory);
}
return(result);
}
public void Read(AssetReader reader)
{
PreQ.Read(reader);
PostQ.Read(reader);
if (IsVector3(reader.Version))
{
Sgn = reader.ReadAsset <Vector3f>();
}
else
{
Sgn.Read(reader);
}
Limit.Read(reader);
Length = reader.ReadSingle();
Type = reader.ReadUInt32();
}
public override void Read(AssetReader reader)
{
PrefabInstanceLayout layout = reader.Layout.PrefabInstance;
if (layout.IsModificationFormat)
{
ReadObject(reader);
if (layout.HasRootGameObject && layout.IsRootGameObjectFirst)
{
RootGameObject.Read(reader);
}
Modification.Read(reader);
SourcePrefab.Read(reader);
if (!layout.IsRootGameObjectFirst)
{
RootGameObject.Read(reader);
}
if (layout.HasIsPrefabAsset)
{
IsPrefabAsset = reader.ReadBoolean();
}
if (layout.HasIsExploded)
{
IsExploded = reader.ReadBoolean();
}
reader.AlignStream();
}
else
{
LastMergeIdentifier.Read(reader);
if (layout.HasLastTemplateIdentifier)
{
LastTemplateIdentifier.Read(reader);
}
Objects = reader.ReadAssetArray <PPtr <EditorExtension> >();
Father = reader.ReadAsset <PPtr <PrefabInstance> >();
IsDataTemplate = reader.ReadBoolean();
reader.AlignStream();
base.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(AssetReader reader)
{
if (IsModificationsFormat(reader.Version))
{
ReadObject(reader);
bool isRootGameObjectFirst = IsRootGameObjectFirst(reader.Version);
if (isRootGameObjectFirst && IsRootGameObjectRelevant(reader.Flags))
{
RootGameObject.Read(reader);
}
Modification.Read(reader);
SourcePrefab.Read(reader);
if (!isRootGameObjectFirst)
{
RootGameObject.Read(reader);
}
if (IsPrefabAssetRelevant(reader.Version))
{
IsPrefabAsset = reader.ReadBoolean();
}
if (IsExplodedRelevant(reader.Version))
{
IsExploded = reader.ReadBoolean();
}
reader.AlignStream();
}
else
{
LastMergeIdentifier.Read(reader);
if (HasLastTemplateIdentifier(reader.Version))
{
LastTemplateIdentifier.Read(reader);
}
Objects = reader.ReadAssetArray <PPtr <EditorExtension> >();
Father = reader.ReadAsset <PPtr <PrefabInstance> >();
IsDataTemplate = reader.ReadBoolean();
reader.AlignStream();
base.Read(reader);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadEditorData(reader.Flags))
{
EditorData = reader.ReadAsset <SpriteAtlasEditorData>();
MasterAtlas.Read(reader);
}
m_packedSprites = reader.ReadAssetArray <PPtr <Sprite> >();
m_packedSpriteNamesToIndex = reader.ReadStringArray();
if (IsReadRenderDataMap(reader.Flags))
{
m_renderDataMap.Read(reader);
}
Tag = reader.ReadString();
IsVariant = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
