public void Read(EndianStream stream)
{
m_conditionConstantArray = stream.ReadArray(() => new OffsetPtr <ConditionConstant>(new ConditionConstant()));
DestinationState = stream.ReadUInt32();
if (IsReadPathID)
{
FullPathID = stream.ReadUInt32();
}
ID = stream.ReadUInt32();
UserID = stream.ReadUInt32();
TransitionDuration = stream.ReadSingle();
TransitionOffset = stream.ReadSingle();
if (IsReadAtomic)
{
Atomic = stream.ReadBoolean();
}
else
{
ExitTime = stream.ReadSingle();
HasExitTime = stream.ReadBoolean();
HasFixedDuration = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
InterruptionSource = stream.ReadInt32();
OrderedInterruption = stream.ReadBoolean();
}
CanTransitionToSelf = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
Avatar.Read(stream);
Controller.Read(stream);
CullingMode = stream.ReadInt32();
if (IsReadUpdateMode)
{
UpdateMode = stream.ReadInt32();
}
ApplyRootMotion = stream.ReadBoolean();
if (IsReadAnimatePhisics)
{
AnimatePhisics = stream.ReadBoolean();
}
if (IsReadBoolFlags)
{
if (IsReadLinearVelocityBlending)
{
LinearVelocityBlending = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
HasTransformHierarchy = stream.ReadBoolean();
AllowConstantClipSamplingOptimization = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
public void Read(EndianStream stream)
{
BlobIndex = stream.ReadUInt32();
Channels.Read(stream);
m_keywordIndices = stream.ReadUInt16Array();
if (IsAlignKeywordIndices)
{
stream.AlignStream(AlignType.Align4);
}
ShaderHardwareTier = stream.ReadByte();
GpuProgramType = (ShaderGpuProgramType)stream.ReadByte();
stream.AlignStream(AlignType.Align4);
m_vectorParams = stream.ReadArray <VectorParameter>();
m_matrixParams = stream.ReadArray <MatrixParameter>();
m_textureParams = stream.ReadArray(() => new TextureParameter(m_assetsFile));
m_bufferParams = stream.ReadArray <BufferBinding>();
m_constantBuffers = stream.ReadArray(() => new ConstantBuffer(m_assetsFile));
m_constantBufferBindings = stream.ReadArray <BufferBinding>();
m_UAVParams = stream.ReadArray <UAVParameter>();
if (IsReadSamplers)
{
m_samplers = stream.ReadArray <SamplerParameter>();
}
if (IsReadShaderRequirements)
{
ShaderRequirements = stream.ReadInt32();
}
}
public void Read(EndianStream stream)
{
m_genericBindings = stream.ReadArray(() => new GenericBinding(m_assetsFile));
stream.AlignStream(AlignType.Align4);
m_pptrCurveMapping = stream.ReadArray(() => new PPtr <Object>(m_assetsFile));
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
NameIndex = stream.ReadInt32();
m_matrixParams = stream.ReadArray <MatrixParameter>();
stream.AlignStream(AlignType.Align4);
m_vectorParams = stream.ReadArray <VectorParameter>();
stream.AlignStream(AlignType.Align4);
Size = stream.ReadInt32();
}
public void Read(EndianStream stream)
{
NumItems = stream.ReadUInt32();
int size = stream.ReadInt32();
m_data = new byte[size];
stream.Read(m_data, 0, size);
stream.AlignStream(AlignType.Align4);
BitSize = stream.ReadByte();
stream.AlignStream(AlignType.Align4);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
ParsedForm.Read(stream);
Name = ParsedForm.Name;
m_platforms = stream.ReadEnum32Array((t) => (GPUPlatform)t);
uint[] offsets = stream.ReadUInt32Array();
uint[] compressedLengths = stream.ReadUInt32Array();
uint[] decompressedLengths = stream.ReadUInt32Array();
byte[] compressedBlob = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
m_subProgramBlobs = new ShaderSubProgramBlob[m_platforms.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < m_platforms.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
memStream.Position = offset;
byte[] decompressedBuffer = new byte[decompressedLength];
using (Lz4Stream lz4Stream = new Lz4Stream(memStream, (int)compressedLength))
{
int read = lz4Stream.Read(decompressedBuffer, 0, decompressedBuffer.Length);
if (read != decompressedLength)
{
throw new Exception($"Can't properly decode shader blob. Read {read} but expected {decompressedLength}");
}
}
using (MemoryStream blobMem = new MemoryStream(decompressedBuffer))
{
using (EndianStream blobStream = new EndianStream(blobMem))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob(AssetsFile);
blob.Read(blobStream);
m_subProgramBlobs[i] = blob;
}
}
}
}
m_dependencies = stream.ReadArray(() => new PPtr <SShader>(AssetsFile));
ShaderIsBaked = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
RootX.Read(stream);
Skeleton.Read(stream);
SkeletonPose.Read(stream);
LeftHand.Read(stream);
RightHand.Read(stream);
m_handles = stream.ReadArray(() => new Handle(m_assetsFile));
m_colliderArray = stream.ReadArray(() => new Collider(m_assetsFile));
m_humanBoneIndex = stream.ReadInt32Array();
m_humanBoneMass = stream.ReadSingleArray();
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();
HasTDoF = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
m_transitionConstantArray = stream.ReadArray(() => new OffsetPtr <SelectorTransitionConstant>(new SelectorTransitionConstant()));
FullPathID = stream.ReadUInt32();
IsEntry = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
MetadataSize = stream.ReadInt32();
if (MetadataSize <= 0)
{
throw new Exception($"Invalid metadata size {MetadataSize} for asset file {m_name}");
}
FileSize = stream.ReadInt32();
if (FileSize <= 0)
{
throw new Exception($"Invalid data size {FileSize} for asset file {m_name}");
}
Generation = (FileGeneration)stream.ReadInt32();
if (!Enum.IsDefined(typeof(FileGeneration), Generation))
{
throw new Exception($"Unsuported file generation {Generation} for asset file '{m_name}'");
}
DataOffset = stream.ReadUInt32();
if (IsReadEndian(Generation))
{
Endianess = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
else
{
Endianess = false;
}
}
public override void Read(EndianStream stream)
{
base.Read(stream);
IsEnabled = stream.ReadByte();
stream.AlignStream(AlignType.Align4);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
if (IsSerialized)
{
throw new NotSupportedException("Use SShader for serialized shaders");
}
if (IsEncoded)
{
uint decompressedSize = stream.ReadUInt32();
int comressedSize = stream.ReadInt32();
byte[] subProgramBlob = new byte[comressedSize];
stream.Read(subProgramBlob, 0, comressedSize);
stream.AlignStream(AlignType.Align4);
if (comressedSize > 0 && decompressedSize > 0)
{
byte[] decompressedBuffer = new byte[decompressedSize];
using (MemoryStream memStream = new MemoryStream(subProgramBlob))
{
using (Lz4Stream lz4Stream = new Lz4Stream(memStream))
{
int read = lz4Stream.Read(decompressedBuffer, 0, (int)decompressedSize);
if (read != decompressedSize)
{
throw new Exception($"Can't properly decode sub porgram prob. Read {read} but expected decompressedSize");
}
}
}
using (MemoryStream memStream = new MemoryStream(decompressedBuffer))
{
using (EndianStream blobStream = new EndianStream(memStream))
{
SubProgramBlob.Read(blobStream);
}
}
}
}
m_dependencies = stream.ReadArray(() => new PPtr <Shader>(AssetsFile));
ShaderIsBaked = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
if (IsReadAnimationType)
{
AnimationType = (AnimationType)stream.ReadInt32();
}
else
{
Legacy = stream.ReadBoolean();
}
Compressed = stream.ReadBoolean();
UseHightQualityCurve = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
m_rotationCurves = stream.ReadArray(() => new QuaternionCurve(AssetsFile));
m_compressedRotationCurves = stream.ReadArray <CompressedAnimationCurve>();
if (Compressed)
{
#warning TODO: decompress
throw new NotImplementedException();
}
if (IsReadEulerCurves)
{
m_eulerCurves = stream.ReadArray(() => new Vector3Curve(AssetsFile));
}
m_positionCurves = stream.ReadArray(() => new Vector3Curve(AssetsFile));
m_scaleCurves = stream.ReadArray(() => new Vector3Curve(AssetsFile));
m_floatCurves = stream.ReadArray(() => new FloatCurve(AssetsFile));
m_PPtrCurves = stream.ReadArray(() => new PPtrCurve(AssetsFile));
SampleRate = stream.ReadSingle();
WrapMode = stream.ReadInt32();
Bounds.Read(stream);
MuscleClipSize = stream.ReadUInt32();
MuscleClip.Read(stream);
ClipBindingConstant.Read(stream);
m_events = stream.ReadArray(() => new AnimationEvent(AssetsFile));
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
NameIndex = stream.ReadInt32();
Index = stream.ReadInt32();
SamplerIndex = stream.ReadInt32();
Dim = stream.ReadByte();
stream.AlignStream(AlignType.Align4);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
ParsedForm.Read(stream);
Name = ParsedForm.Name.Replace("/", "_");
m_platforms = stream.ReadUInt32Array();
m_offsets = stream.ReadUInt32Array();
m_compressedLengths = stream.ReadUInt32Array();
m_decompressedLengths = stream.ReadUInt32Array();
m_compressedBlob = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
m_dependencies = stream.ReadArray(() => new PPtr <SShader>(AssetsFile));
ShaderIsBaked = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
NameIndex = stream.ReadInt32();
Index = stream.ReadInt32();
ArraySize = stream.ReadInt32();
Type = (ShaderParamType)stream.ReadByte();
RowCount = stream.ReadByte();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
NameIndex = stream.ReadInt32();
Index = stream.ReadInt32();
ArraySize = stream.ReadInt32();
Type = stream.ReadByte();
Dim = stream.ReadByte();
stream.AlignStream(AlignType.Align4);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
ParentPrefab.Read(stream);
RootGameObject.Read(stream);
IsPrefabParent = stream.ReadBoolean();
stream.AlignStream(AlignType.Align64);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
ParentPrefab.Read(stream);
RootGameObject.Read(stream);
IsPrefabParent = stream.ReadBoolean();
stream.AlignStream(AlignType.Align64);
throw new NotSupportedException("Currently EditorExtension's PrefabInternal field doesn't support Unity's prefabs");
}
public void Read(EndianStream stream)
{
m_curve = stream.ReadArray(() => new PPtrKeyframe(m_assetsFile));
stream.AlignStream(AlignType.Align4);
Attribute = stream.ReadStringAligned();
Path = stream.ReadStringAligned();
ClassID = stream.ReadInt32();
Script.Read(stream);
}
public void Read(EndianStream stream)
{
Name = stream.ReadStringAligned();
RtBlend0.Read(stream);
RtBlend1.Read(stream);
RtBlend2.Read(stream);
RtBlend3.Read(stream);
RtBlend4.Read(stream);
RtBlend5.Read(stream);
RtBlend6.Read(stream);
RtBlend7.Read(stream);
RtSeparateBlend = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
if (IsReadZClip)
{
ZClip.Read(stream);
}
ZTest.Read(stream);
ZWrite.Read(stream);
Culling.Read(stream);
OffsetFactor.Read(stream);
OffsetUnits.Read(stream);
AlphaToMask.Read(stream);
StencilOp.Read(stream);
StencilOpFront.Read(stream);
StencilOpBack.Read(stream);
StencilReadMask.Read(stream);
StencilWriteMask.Read(stream);
StencilRef.Read(stream);
FogStart.Read(stream);
FogEnd.Read(stream);
FogDensity.Read(stream);
FogColor.Read(stream);
FogMode = (FogMode)stream.ReadInt32();
GpuProgramID = stream.ReadInt32();
Tags.Read(stream);
LOD = stream.ReadInt32();
Lighting = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
PropInfo.Read(stream);
m_subShaders = stream.ReadArray <SerializedSubShader>();
Name = stream.ReadStringAligned();
CustomEditorName = stream.ReadStringAligned();
FallbackName = stream.ReadStringAligned();
m_dependencies = stream.ReadArray <SerializedShaderDependency>();
DisableNoSubshadersMessage = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
BlobIndex = stream.ReadUInt32();
Channels.Read(stream);
m_keywordIndices = stream.ReadUInt16Array();
stream.AlignStream(AlignType.Align4);
ShaderHardwareTier = stream.ReadByte();
GpuProgramType = stream.ReadByte();
stream.AlignStream(AlignType.Align4);
m_vectorParams = stream.ReadArray <VectorParameter>();
m_matrixParams = stream.ReadArray <MatrixParameter>();
m_textureParams = stream.ReadArray <TextureParameter>();
m_bufferParams = stream.ReadArray <BufferBinding>();
m_constantBuffers = stream.ReadArray <ConstantBuffer>();
m_constantBufferBindings = stream.ReadArray <BufferBinding>();
m_UAVParams = stream.ReadArray <UAVParameter>();
m_samplers = stream.ReadArray <SamplerParameter>();
}
public override void Read(EndianStream stream)
{
base.Read(stream);
m_scenes = stream.ReadStringArray();
if (IsReadPreloadPlugin)
{
m_preloadedPlugins = stream.ReadStringArray();
}
if (IsReadEnabledVRDevices)
{
m_enabledVRDevices = stream.ReadStringArray();
if (IsReadBuildTags)
{
m_buildTags = stream.ReadStringArray();
BuildGUID.Read(stream);
}
}
// bool flags
HasPROVersion = stream.ReadBoolean();
IsNoWatermarkBuild = stream.ReadBoolean();
IsPrototypingBuild = stream.ReadBoolean();
IsEducationalBuild = stream.ReadBoolean();
if (IsReadBoolFlags)
{
IsEmbedded = stream.ReadBoolean();
HasPublishingRights = stream.ReadBoolean();
HasShadows = stream.ReadBoolean();
HasSoftShadows = stream.ReadBoolean();
}
if (IsReadMoreBoolFlags)
{
HasLocalLightShadows = stream.ReadBoolean();
HasAdvancedVersion = stream.ReadBoolean();
EnableDynamicBatching = stream.ReadBoolean();
IsDebugBuild = stream.ReadBoolean();
}
if (IsReadEvenMoreBoolFlags)
{
UsesOnMouseEvents = stream.ReadBoolean();
HasClusterRendering = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
BSVersion = stream.ReadStringAligned();
AuthToken = stream.ReadStringAligned();
m_runtimeClassHashes.Read(stream);
m_scriptHashes.Read(stream);
m_graphicsAPIs = stream.ReadInt32Array();
}
public override void Read(EndianStream stream)
{
base.Read(stream);
if (IsSerialized)
{
SerializedShader.Read(stream);
}
else
{
Shader.Read(stream);
}
if (IsReadKeywords)
{
if (IsKeywordsArray)
{
m_shaderKeywordsArray = stream.ReadStringArray();
}
else
{
ShaderKeywords = stream.ReadStringAligned();
}
}
if (IsReadLightmapFlags)
{
LightmapFlags = stream.ReadUInt32();
if (IsReadOtherFlags)
{
EnableInstancingVariants = stream.ReadBoolean();
DoubleSidedGI = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadCustomRenderQueue)
{
CustomRenderQueue = stream.ReadInt32();
}
if (IsReadStringTagMap)
{
StringTagMap.Read(stream);
if (IsReadDisabledShaderPasses)
{
m_disabledShaderPasses = stream.ReadStringArray();
}
}
SavedProperties.Read(stream);
}
public void Read(EndianStream stream)
{
NameIndex = stream.ReadInt32();
Index = stream.ReadInt32();
SamplerIndex = stream.ReadInt32();
if (IsReadMultiSampled)
{
MultiSampled = stream.ReadBoolean();
}
Dim = stream.ReadByte();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
StateMachineIndex = stream.ReadUInt32();
StateMachineMotionSetIndex = stream.ReadUInt32();
BodyMask.Read(stream);
SkeletonMask.Read(stream);
Binding = stream.ReadUInt32();
LayerBlendingMode = stream.ReadInt32();
DefaultWeight = stream.ReadSingle();
IKPass = stream.ReadBoolean();
SyncedLayerAffectsTiming = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
DefaultAnimation.Read(stream);
m_animations = stream.ReadArray(() => new PPtr <AnimationClip>(AssetsFile));
WrapMode = stream.ReadInt32();
PlayAutomatically = stream.ReadBoolean();
AnimatePhysics = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
CullingType = stream.ReadInt32();
}
public void Read(EndianStream stream)
{
FirstVertex = stream.ReadUInt32();
VertexCount = stream.ReadUInt32();
if (IsReadAABB)
{
AabbMinDelta.Read(stream);
AabbMaxDelta.Read(stream);
}
HasNormals = stream.ReadBoolean();
HasTangents = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public void Read(EndianStream stream)
{
Reset();
Curve.Read(stream, () => new KeyframeTpl <T>(m_assetsFile));
stream.AlignStream(AlignType.Align4);
PreInfinity = stream.ReadInt32();
PostInfinity = stream.ReadInt32();
if (IsReadRotationOrder)
{
RotationOrder = stream.ReadInt32();
}
}
