public void Read(AssetStream stream)
{
m_bakedConvexCollisionMesh = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
m_bakedTriangleCollisionMesh = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
Bounds.Read(stream);
m_layerIndices = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
m_numberOfObjects = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
CurrentChannels = stream.ReadUInt32();
VertexCount = stream.ReadUInt32();
if (IsReadChannels(stream.Version))
{
m_channels = stream.ReadArray <ChannelInfo>();
stream.AlignStream(AlignType.Align4);
}
if (IsReadStream(stream.Version))
{
if (IsStreamStatic(stream.Version))
{
m_streams = new StreamInfo[4];
for (int i = 0; i < 4; i++)
{
StreamInfo streamInfo = new StreamInfo();
streamInfo.Read(stream);
m_streams[i] = streamInfo;
}
}
else
{
m_streams = stream.ReadArray <StreamInfo>();
}
}
m_data = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
NumItems = stream.ReadUInt32();
m_data = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
BitSize = stream.ReadByte();
stream.AlignStream(AlignType.Align4);
}
public void Read(AssetStream stream)
{
m_meshData = stream.ReadByteArray();
if (IsReadHash(stream.Version))
{
Hash.Read(stream);
}
}
public void Read(AssetStream stream)
{
m_probeOcclusionLightIndex = stream.ReadInt32Array();
m_occlusion = stream.ReadSingleArray();
if (IsReadOcclusionMaskChannel(stream.Version))
{
m_occlusionMaskChannel = stream.ReadByteArray();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Width = stream.ReadInt32();
Height = stream.ReadInt32();
CompleteImageSize = stream.ReadInt32();
TextureFormat = (TextureFormat)stream.ReadInt32();
if (IsBoolMinMap(stream.Version))
{
MipMap = stream.ReadBoolean();
if (MipMap)
{
int maxSide = Math.Max(Width, Height);
MipCount = Convert.ToInt32(Math.Log(maxSide) / Math.Log(2));
}
else
{
MipCount = 1;
}
}
else
{
MipCount = stream.ReadInt32();
}
if (IsReadIsReadable(stream.Version))
{
IsReadable = stream.ReadBoolean();
}
if (IsReadReadAllowed(stream.Version))
{
ReadAllowed = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
ImageCount = stream.ReadInt32();
TextureDimension = stream.ReadInt32();
TextureSettings.Read(stream);
if (IsReadLightmapFormat(stream.Version))
{
LightmapFormat = stream.ReadInt32();
}
if (IsReadColorSpace(stream.Version))
{
ColorSpace = (ColorSpace)stream.ReadInt32();
}
m_imageData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
if (IsReadStreamData(stream.Version))
{
StreamData.Read(stream);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Script = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
if (IsReadPath(stream.Version))
{
PathName = stream.ReadStringAligned();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
IsLoop = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
AudioClip.Read(stream);
m_movieData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
ColorSpace = stream.ReadInt32();
}
public override void Read(AssetStream stream)
{
base.Read(stream);
m_PVSData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
m_scenes = stream.ReadArray <OcclusionScene>();
if (IsReadStaticRenderers(stream.Flags))
{
m_staticRenderers = stream.ReadArray <SceneObjectIdentifier>();
m_portals = stream.ReadArray <SceneObjectIdentifier>();
}
}
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);
}
if (IsReadBindpose(stream.Version))
{
m_bindpose = stream.ReadArray <Matrix4x4f>();
}
if (IsReadSourceSkin(stream.Version))
{
m_sourceSkin = stream.ReadArray <BoneWeights4>();
}
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 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();
}
if (IsReadOcclusionBakeSettings(stream.Version, stream.Flags))
{
if (IsReadOcclusionBakeSettingsFirst(stream.Version))
{
OcclusionBakeSettings.Read(stream);
}
}
if (IsReadSceneGUID(stream.Version))
{
SceneGUID.Read(stream);
OcclusionCullingData.Read(stream);
}
if (IsReadStaticRenderers(stream.Version, stream.Flags))
{
m_staticRenderers = stream.ReadArray <PPtr <Renderer> >();
}
if (IsReadPortals(stream.Version, stream.Flags))
{
m_portals = stream.ReadArray <PPtr <OcclusionPortal> >();
}
if (IsReadOcclusionBakeSettings(stream.Version, stream.Flags))
{
if (!IsReadOcclusionBakeSettingsFirst(stream.Version))
{
OcclusionBakeSettings.Read(stream);
}
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Scene.Read(stream);
if (IsReadLightmaps(stream.Flags))
{
m_lightmaps = stream.ReadArray <LightmapData>();
stream.AlignStream(AlignType.Align4);
LightProbes.Read(stream);
LightmapsMode = stream.ReadInt32();
BakedAmbientProbeInLinear.Read(stream);
m_lightmappedRendererData = stream.ReadArray <RendererData>();
stream.AlignStream(AlignType.Align4);
m_lightmappedRendererDataIDs = stream.ReadArray <SceneObjectIdentifier>();
stream.AlignStream(AlignType.Align4);
EnlightenSceneMapping.Read(stream);
m_enlightenSceneMappingRendererIDs = stream.ReadArray <SceneObjectIdentifier>();
stream.AlignStream(AlignType.Align4);
m_lights = stream.ReadArray <SceneObjectIdentifier>();
stream.AlignStream(AlignType.Align4);
m_lightBakingOutputs = stream.ReadArray <LightBakingOutput>();
stream.AlignStream(AlignType.Align4);
m_bakedReflectionProbeCubemaps = stream.ReadArray <PPtr <Texture> >();
m_bakedReflectionProbes = stream.ReadArray <SceneObjectIdentifier>();
stream.AlignStream(AlignType.Align4);
if (IsReadEnlightenData(stream.Flags))
{
m_enlightenData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
EnlightenDataVersion = stream.ReadInt32();
}
}
public void Read(AssetStream stream)
{
int magic = stream.ReadInt32();
if (magic != GetMagicNumber(stream.Version))
{
throw new Exception($"Magic number {magic} doesn't match");
}
ProgramType = (ShaderGpuProgramType)stream.ReadInt32();
int unknown1 = stream.ReadInt32();
int unknown2 = stream.ReadInt32();
int unknown3 = stream.ReadInt32();
if (IsReadUnknown4(stream.Version))
{
int unknown4 = stream.ReadInt32();
}
m_keywords = stream.ReadStringArray();
m_programData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
int sourceMap = stream.ReadInt32();
int bindCount = stream.ReadInt32();
ShaderBindChannel[] channels = new ShaderBindChannel[bindCount];
for (int i = 0; i < bindCount; i++)
{
ShaderChannel source = (ShaderChannel)stream.ReadUInt32();
VertexComponent target = (VertexComponent)stream.ReadUInt32();
ShaderBindChannel channel = new ShaderBindChannel(source, target);
channels[i] = channel;
sourceMap |= 1 << (int)source;
}
BindChannels = new ParserBindChannels(channels, sourceMap);
List <VectorParameter> vectors = new List <VectorParameter>();
List <MatrixParameter> matrices = new List <MatrixParameter>();
List <TextureParameter> textures = new List <TextureParameter>();
List <BufferBinding> buffers = new List <BufferBinding>();
List <UAVParameter> uavs = IsReadUAVParameters(stream.Version) ? new List <UAVParameter>() : null;
List <SamplerParameter> samplers = IsReadSamplerParameters(stream.Version) ? new List <SamplerParameter>() : null;
List <BufferBinding> constBindings = new List <BufferBinding>();
List <StructParameter> structs = IsReadStructParameters(stream.Version) ? new List <StructParameter>() : null;
int paramGroupCount = stream.ReadInt32();
m_constantBuffers = new ConstantBuffer[paramGroupCount - 1];
for (int i = 0; i < paramGroupCount; i++)
{
vectors.Clear();
matrices.Clear();
string name = stream.ReadStringAligned();
int usedSize = stream.ReadInt32();
int paramCount = stream.ReadInt32();
for (int j = 0; j < paramCount; j++)
{
string paramName = stream.ReadStringAligned();
ShaderParamType paramType = (ShaderParamType)stream.ReadInt32();
int rows = stream.ReadInt32();
int dimension = stream.ReadInt32();
bool isMatrix = stream.ReadInt32() > 0;
int arraySize = stream.ReadInt32();
int index = stream.ReadInt32();
if (isMatrix)
{
MatrixParameter matrix = IsAllParamArgs(stream.Version) ?
new MatrixParameter(paramName, paramType, index, arraySize, rows) :
new MatrixParameter(paramName, paramType, index, rows);
matrices.Add(matrix);
}
else
{
VectorParameter vector = IsAllParamArgs(stream.Version) ?
new VectorParameter(paramName, paramType, index, arraySize, dimension) :
new VectorParameter(paramName, paramType, index, dimension);
vectors.Add(vector);
}
}
if (i == 0)
{
m_vectorParameters = vectors.ToArray();
m_matrixParameters = matrices.ToArray();
}
else
{
ConstantBuffer constBuffer = new ConstantBuffer(name, matrices.ToArray(), vectors.ToArray(), usedSize);
m_constantBuffers[i - 1] = constBuffer;
}
if (IsReadStructParameters(stream.Version))
{
int structCount = stream.ReadInt32();
for (int j = 0; j < structCount; j++)
{
vectors.Clear();
matrices.Clear();
string structName = stream.ReadStringAligned();
int index = stream.ReadInt32();
int arraySize = stream.ReadInt32();
int structSize = stream.ReadInt32();
int strucParamCount = stream.ReadInt32();
for (int k = 0; k < strucParamCount; k++)
{
string paramName = stream.ReadStringAligned();
paramName = $"{structName}.{paramName}";
ShaderParamType paramType = (ShaderParamType)stream.ReadInt32();
int rows = stream.ReadInt32();
int dimension = stream.ReadInt32();
bool isMatrix = stream.ReadInt32() > 0;
int vectorArraySize = stream.ReadInt32();
int paramIndex = stream.ReadInt32();
if (isMatrix)
{
MatrixParameter matrix = IsAllParamArgs(stream.Version) ?
new MatrixParameter(paramName, paramType, paramIndex, vectorArraySize, rows) :
new MatrixParameter(paramName, paramType, paramIndex, rows);
matrices.Add(matrix);
}
else
{
VectorParameter vector = IsAllParamArgs(stream.Version) ?
new VectorParameter(paramName, paramType, paramIndex, vectorArraySize, dimension) :
new VectorParameter(paramName, paramType, paramIndex, dimension);
vectors.Add(vector);
}
}
StructParameter @struct = new StructParameter(structName, index, arraySize, structSize, vectors.ToArray(), matrices.ToArray());
structs.Add(@struct);
}
}
}
int paramGroup2Count = stream.ReadInt32();
for (int i = 0; i < paramGroup2Count; i++)
{
string name = stream.ReadStringAligned();
int type = stream.ReadInt32();
int index = stream.ReadInt32();
int extraValue = stream.ReadInt32();
if (type == 0)
{
TextureParameter texture;
if (IsReadMultiSampled(stream.Version))
{
bool isMultiSampled = stream.ReadUInt32() > 0;
texture = new TextureParameter(name, index, isMultiSampled, extraValue);
}
else
{
texture = new TextureParameter(name, index, extraValue);
}
textures.Add(texture);
}
else if (type == 1)
{
BufferBinding binding = new BufferBinding(name, index);
constBindings.Add(binding);
}
else if (type == 2)
{
BufferBinding buffer = new BufferBinding(name, index);
buffers.Add(buffer);
}
else if (type == 3 && IsReadUAVParameters(stream.Version))
{
UAVParameter uav = new UAVParameter(name, index, extraValue);
uavs.Add(uav);
}
else if (type == 4 && IsReadSamplerParameters(stream.Version))
{
SamplerParameter sampler = new SamplerParameter((uint)extraValue, index);
samplers.Add(sampler);
}
else
{
throw new Exception($"Unupported parameter type {type}");
}
}
m_textureParameters = textures.ToArray();
m_bufferParameters = buffers.ToArray();
if (IsReadUAVParameters(stream.Version))
{
m_UAVParameters = uavs.ToArray();
}
if (IsReadSamplerParameters(stream.Version))
{
m_samplerParameters = samplers.ToArray();
}
m_constantBufferBindings = constBindings.ToArray();
if (IsReadStructParameters(stream.Version))
{
m_structParameters = structs.ToArray();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsModeShort(stream.Version))
{
RenderMode = stream.ReadUInt16();
}
else
{
RenderMode = stream.ReadInt32();
}
if (IsSortModeFirst(stream.Version))
{
SortMode = stream.ReadUInt16();
}
if (IsReadMinParticleSize(stream.Version))
{
MinParticleSize = stream.ReadSingle();
}
MaxParticleSize = stream.ReadSingle();
CameraVelocityScale = stream.ReadSingle();
VelocityScale = stream.ReadSingle();
LengthScale = stream.ReadSingle();
SortingFudge = stream.ReadSingle();
if (IsReadNormalDirection(stream.Version))
{
NormalDirection = stream.ReadSingle();
}
if (!IsSortModeFirst(stream.Version))
{
SortMode = stream.ReadInt32();
}
if (IsReadRenderAlignment(stream.Version))
{
RenderAlignment = stream.ReadInt32();
Pivot.Read(stream);
}
if (IsReadUseCustomVertexStreams(stream.Version))
{
UseCustomVertexStreams = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
if (IsReadVertexStreamMask(stream.Version))
{
VertexStreamMask = stream.ReadInt32();
}
if (IsReadVertexStreams(stream.Version))
{
m_vertexStreams = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
Mesh.Read(stream);
if (IsReadMeshes(stream.Version))
{
Mesh1.Read(stream);
Mesh2.Read(stream);
Mesh3.Read(stream);
}
if (IsReadMaskInteraction(stream.Version))
{
MaskInteraction = stream.ReadInt32();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadFontImpl(stream.Version))
{
LineSpacing = stream.ReadSingle();
DefaultMaterial.Read(stream);
FontSize = stream.ReadSingle();
Texture.Read(stream);
stream.AlignStream(AlignType.Align4);
}
if (IsShortAsciiStartOffset(stream.Version))
{
AsciiStartOffset = stream.ReadInt16();
FontCountX = stream.ReadInt16();
FontCountY = stream.ReadInt16();
}
else
{
AsciiStartOffset = stream.ReadInt32();
if (IsReadFontCount(stream.Version))
{
FontCountX = stream.ReadInt32();
FontCountY = stream.ReadInt32();
}
}
if (IsReadKerning(stream.Version))
{
Kerning = stream.ReadSingle();
}
if (IsReadTracking(stream.Version))
{
Tracking = stream.ReadSingle();
}
if (!IsReadFontImpl(stream.Version))
{
LineSpacing = stream.ReadSingle();
}
if (IsReadCharacterSpacing(stream.Version))
{
CharacterSpacing = stream.ReadInt32();
CharacterPadding = stream.ReadInt32();
}
if (IsReadPerCharacterKerning(stream.Version))
{
if (IsBytePerCharacterKerning(stream.Version))
{
m_perCharacterKerningByte = stream.ReadTupleByteSingleArray();
}
else
{
m_perCharacterKerning = stream.ReadTupleIntFloatArray();
}
}
ConvertCase = stream.ReadInt32();
if (!IsReadFontImpl(stream.Version))
{
DefaultMaterial.Read(stream);
}
m_characterRects = stream.ReadArray <CharacterInfo>();
if (!IsReadFontImpl(stream.Version))
{
Texture.Read(stream);
}
if (IsReadGridFont(stream.Version))
{
if (IsGridFontFirst(stream.Version))
{
GridFont = stream.ReadBoolean();
}
}
if (IsByteKerningValues(stream.Version))
{
m_kerningValuesByte = new Dictionary <Tuple <byte, byte>, float>();
m_kerningValuesByte.Read(stream);
}
else
{
m_kerningValues.Read(stream);
}
if (IsReadPixelScale(stream.Version))
{
PixelScale = stream.ReadSingle();
stream.AlignStream(AlignType.Align4);
}
if (IsReadGridFont(stream.Version))
{
if (!IsGridFontFirst(stream.Version))
{
GridFont = stream.ReadBoolean();
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
}
}
if (IsReadFontData(stream.Version))
{
m_fontData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
if (!IsReadFontImpl(stream.Version))
{
FontSize = stream.ReadSingle();
}
Ascent = stream.ReadSingle();
}
if (IsReadDescent(stream.Version))
{
Descent = stream.ReadSingle();
}
if (IsReadDefaultStyle(stream.Version))
{
DefaultStyle = (FontStyle)stream.ReadUInt32();
m_fontNames = stream.ReadStringArray();
}
if (IsReadFallbackFonts(stream.Version))
{
m_fallbackFonts = stream.ReadArray <PPtr <Font> >();
stream.AlignStream(AlignType.Align4);
FontRenderingMode = (FontRenderingMode)stream.ReadInt32();
}
if (IsReadUseLegacyBoundsCalculation(stream.Version))
{
UseLegacyBoundsCalculation = stream.ReadBoolean();
}
if (IsReadShouldRoundAdvanceValue(stream.Version))
{
ShouldRoundAdvanceValue = stream.ReadBoolean();
}
}
public override void Read(AssetStream stream)
{
if (IsSerialized(stream.Version))
{
ReadBase(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 (AssetStream blobStream = new AssetStream(blobMem, stream.Version, stream.Platform))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob();
blob.Read(blobStream);
m_subProgramBlobs[i] = blob;
}
}
}
}
}
else
{
base.Read(stream);
if (IsEncoded(stream.Version))
{
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, decompressedBuffer.Length);
if (read != decompressedSize)
{
throw new Exception($"Can't properly decode sub porgram blob. Read {read} but expected {decompressedSize}");
}
}
}
using (MemoryStream memStream = new MemoryStream(decompressedBuffer))
{
using (AssetStream blobStream = new AssetStream(memStream, stream.Version, stream.Platform))
{
SubProgramBlob.Read(blobStream);
}
}
}
}
if (IsReadFallback(stream.Version))
{
Fallback.Read(stream);
}
if (IsReadDefaultProperties(stream.Version))
{
DefaultProperties.Read(stream);
}
if (IsReadStaticProperties(stream.Version))
{
StaticProperties.Read(stream);
}
}
if (IsReadDependencies(stream.Version))
{
m_dependencies = stream.ReadArray <PPtr <Shader> >();
}
if (IsReadNonModifiableTextures(stream.Version))
{
m_nonModifiableTextures = stream.ReadArray <PPtr <Texture> >();
}
if (IsReadShaderIsBaked(stream.Version))
{
ShaderIsBaked = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadLODData(stream.Version))
{
m_LODData = stream.ReadArray <LOD>();
}
if (IsReadIndicesUsage(stream.Version))
{
Use16bitIndices = stream.ReadInt32() > 0;
}
if (IsReadIndexBuffer(stream.Version))
{
if (IsReadIndexBufferFirst(stream.Version))
{
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadSubMeshes(stream.Version))
{
m_subMeshes = stream.ReadArray <SubMesh>();
}
if (IsReadBlendShapes(stream.Version))
{
Shapes.Read(stream);
}
if (IsReadBindPosesFirst(stream.Version))
{
m_bindPoses = stream.ReadArray <Matrix4x4f>();
}
if (IsReadBoneNameHashes(stream.Version))
{
m_boneNameHashes = stream.ReadUInt32Array();
RootBoneNameHash = stream.ReadUInt32();
}
if (IsReadMeshCompression(stream.Version))
{
MeshCompression = stream.ReadByte();
}
if (IsReadStreamCompression(stream.Version))
{
StreamCompression = stream.ReadByte();
}
if (IsReadIsReadable(stream.Version))
{
IsReadable = stream.ReadBoolean();
KeepVertices = stream.ReadBoolean();
KeepIndices = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadIndexFormat(stream.Version))
{
if (IsReadIndexFormatCondition(stream.Version))
{
if (MeshCompression == 0)
{
IndexFormat = stream.ReadInt32();
}
}
else
{
IndexFormat = stream.ReadInt32();
}
}
if (IsReadIndexBuffer(stream.Version))
{
if (!IsReadIndexBufferFirst(stream.Version))
{
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadVertices(stream.Version))
{
if (IsReadVertexData(stream.Version))
{
if (MeshCompression != 0)
{
m_vertices = stream.ReadArray <Vector3f>();
}
}
else
{
m_vertices = stream.ReadArray <Vector3f>();
}
}
if (IsReadSkin(stream.Version))
{
m_skin = stream.ReadArray <BoneWeights4>();
}
if (IsReadBindPoses(stream.Version))
{
if (!IsReadBindPosesFirst(stream.Version))
{
m_bindPoses = stream.ReadArray <Matrix4x4f>();
}
}
if (IsReadVertexData(stream.Version))
{
if (IsReadOnlyVertexData(stream.Version))
{
VertexData.Read(stream);
}
else
{
if (MeshCompression == 0)
{
VertexData.Read(stream);
}
else
{
m_UV = stream.ReadArray <Vector2f>();
m_UV1 = stream.ReadArray <Vector2f>();
m_tangents = stream.ReadArray <Vector4f>();
m_normals = stream.ReadArray <Vector3f>();
m_colors = stream.ReadArray <ColorRGBA32>();
}
}
}
else
{
m_UV = stream.ReadArray <Vector2f>();
if (IsReadUV1(stream.Version))
{
m_UV1 = stream.ReadArray <Vector2f>();
}
if (IsReadTangentSpace(stream.Version))
{
m_tangentSpace = stream.ReadArray <Tangent>();
}
else
{
m_tangents = stream.ReadArray <Vector4f>();
m_normals = stream.ReadArray <Vector3f>();
}
}
if (IsReadAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadCompressedMesh(stream.Version))
{
CompressedMesh.Read(stream);
}
LocalAABB.Read(stream);
if (IsReadColors(stream.Version))
{
if (!IsReadVertexData(stream.Version))
{
m_colors = stream.ReadArray <ColorRGBA32>();
}
}
if (IsReadCollisionTriangles(stream.Version))
{
m_collisionTriangles = stream.ReadUInt32Array();
CollisionVertexCount = stream.ReadInt32();
}
if (IsReadMeshUsageFlags(stream.Version))
{
MeshUsageFlags = stream.ReadInt32();
}
if (IsReadCollision(stream.Version))
{
CollisionData.Read(stream);
}
if (IsReadMeshMetrics(stream.Version))
{
m_meshMetrics = new float[2];
m_meshMetrics[0] = stream.ReadSingle();
m_meshMetrics[1] = stream.ReadSingle();
}
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadLoadType(stream.Version))
{
LoadType = (AudioClipLoadType)stream.ReadInt32();
Channels = stream.ReadInt32();
Frequency = stream.ReadInt32();
BitsPerSample = stream.ReadInt32();
Length = stream.ReadSingle();
if (IsReadIsTrackerFormat(stream.Version))
{
IsTrackerFormat = stream.ReadBoolean();
}
if (IsReadAmbisonic(stream.Version))
{
Ambisonic = stream.ReadBoolean();
}
if (IsAlignTrackerFormat(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadAudioClipFlags(stream.Version))
{
AudioClipFlags = stream.ReadInt32();
}
if (IsReadFSBResourceFirst(stream.Version))
{
FSBResource.Read(stream);
}
SubsoundIndex = stream.ReadInt32();
PreloadAudioData = stream.ReadBoolean();
LoadInBackground = stream.ReadBoolean();
Legacy3D = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
if (!IsReadFSBResourceFirst(stream.Version))
{
FSBResource.Read(stream);
}
if (IsReadType(stream.Version))
{
Type = (FMODSoundType)stream.ReadInt32();
}
if (IsReadCompressionFormat(stream.Version))
{
CompressionFormat = (AudioCompressionFormat)stream.ReadInt32();
}
stream.AlignStream(AlignType.Align4);
}
else
{
if (IsReadDecompressOnLoadFirst(stream.Version))
{
DecompressOnLoad = stream.ReadBoolean();
}
Format = (FMODSoundFormat)stream.ReadInt32();
if (IsReadType(stream.Version))
{
Type = (FMODSoundType)stream.ReadInt32();
}
if (IsReadLength(stream.Version))
{
Length = stream.ReadSingle();
Frequency = stream.ReadInt32();
Size = stream.ReadInt32();
}
if (IsReadDecompressOnLoadSecond(stream.Version))
{
DecompressOnLoad = stream.ReadBoolean();
}
if (IsRead3D(stream.Version))
{
Legacy3D = stream.ReadBoolean();
}
if (IsReadUseHardware(stream.Version))
{
UseHardware = stream.ReadBoolean();
}
if (IsAlignBools(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsStreamInt32(stream.Version))
{
Stream = stream.ReadInt32();
}
if (IsReadStreamingInfo(stream.Version))
{
if (Stream == 2)
{
string resImageName = $"{File.Name}.resS";
StreamingInfo.Read(stream, resImageName);
}
else
{
m_audioData = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
}
else
{
m_audioData = stream.ReadByteArray();
if (IsAlignAudioData(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadDecompressOnLoadThird(stream.Version))
{
DecompressOnLoad = stream.ReadBoolean();
}
if (IsReadStream(stream.Version))
{
if (!IsStreamInt32(stream.Version))
{
Stream = stream.ReadBoolean() ? 1 : 0;
}
}
}
}
public void Read(AssetStream stream)
{
switch (Type.Type)
{
case PrimitiveType.Bool:
if (IsArray)
{
Value = stream.ReadBooleanArray();
}
else
{
Value = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
break;
case PrimitiveType.Byte:
if (IsArray)
{
Value = stream.ReadByteArray();
}
else
{
Value = stream.ReadByte();
}
stream.AlignStream(AlignType.Align4);
break;
case PrimitiveType.Char:
if (IsArray)
{
Value = stream.ReadCharArray();
}
else
{
Value = stream.ReadChar();
}
stream.AlignStream(AlignType.Align4);
break;
case PrimitiveType.Short:
if (IsArray)
{
Value = stream.ReadInt16Array();
}
else
{
Value = stream.ReadInt16();
}
stream.AlignStream(AlignType.Align4);
break;
case PrimitiveType.UShort:
if (IsArray)
{
Value = stream.ReadUInt16Array();
}
else
{
Value = stream.ReadUInt16();
}
stream.AlignStream(AlignType.Align4);
break;
case PrimitiveType.Int:
if (IsArray)
{
Value = stream.ReadInt32Array();
}
else
{
Value = stream.ReadInt32();
}
break;
case PrimitiveType.UInt:
if (IsArray)
{
Value = stream.ReadUInt32Array();
}
else
{
Value = stream.ReadUInt32();
}
break;
case PrimitiveType.Long:
if (IsArray)
{
Value = stream.ReadInt64Array();
}
else
{
Value = stream.ReadInt64();
}
break;
case PrimitiveType.ULong:
if (IsArray)
{
Value = stream.ReadUInt64Array();
}
else
{
Value = stream.ReadUInt64();
}
break;
case PrimitiveType.Single:
if (IsArray)
{
Value = stream.ReadSingleArray();
}
else
{
Value = stream.ReadSingle();
}
break;
case PrimitiveType.Double:
if (IsArray)
{
Value = stream.ReadDoubleArray();
}
else
{
Value = stream.ReadDouble();
}
break;
case PrimitiveType.String:
if (IsArray)
{
Value = stream.ReadStringArray();
}
else
{
Value = stream.ReadStringAligned();
}
break;
case PrimitiveType.Complex:
if (IsArray)
{
int count = stream.ReadInt32();
IScriptStructure[] structures = new IScriptStructure[count];
for (int i = 0; i < count; i++)
{
IScriptStructure structure = Type.ComplexType.CreateCopy();
structure.Read(stream);
structures[i] = structure;
}
Value = structures;
}
else
{
IScriptStructure structure = Type.ComplexType.CreateCopy();
structure.Read(stream);
Value = structure;
}
break;
default:
throw new NotImplementedException($"Unknown {nameof(PrimitiveType)} '{Type.Type}'");
}
}
