public void Read(AssetReader reader)
{
BakedConvexCollisionMesh = reader.ReadByteArray();
reader.AlignStream();
BakedTriangleCollisionMesh = reader.ReadByteArray();
reader.AlignStream();
}
public void Read(AssetReader reader)
{
m_bakedConvexCollisionMesh = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
m_bakedTriangleCollisionMesh = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
Bounds.Read(reader);
m_layerIndices = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
m_numberOfObjects = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
Bounds.Read(reader);
LayerIndices = reader.ReadByteArray();
reader.AlignStream();
NumberOfObjects = reader.ReadByteArray();
reader.AlignStream();
}
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 override void Read(AssetReader reader)
{
base.Read(reader);
m_meshData = reader.ReadByteArray();
m_heightmaps = reader.ReadAssetArray <HeightmapData>();
}
public void Read(AssetReader reader)
{
NumItems = reader.ReadUInt32();
m_data = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
BitSize = reader.ReadByte();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
m_meshData = reader.ReadByteArray();
if (IsReadHash(reader.Version))
{
Hash.Read(reader);
}
}
public void Read(AssetReader reader)
{
m_probeOcclusionLightIndex = reader.ReadInt32Array();
m_occlusion = reader.ReadSingleArray();
if (IsReadOcclusionMaskChannel(reader.Version))
{
m_occlusionMaskChannel = reader.ReadByteArray();
}
}
public void Read(AssetReader reader)
{
ProbeOcclusionLightIndex = reader.ReadInt32Array();
Occlusion = reader.ReadSingleArray();
if (HasOcclusionMaskChannel(reader.Version))
{
OcclusionMaskChannel = reader.ReadByteArray();
}
}
public void Read(AssetReader reader)
{
NumItems = (int)reader.ReadUInt32();
Range = reader.ReadSingle();
Start = reader.ReadSingle();
Data = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
BitSize = reader.ReadByte();
reader.AlignStream(AlignType.Align4);
}
public void Read(AssetReader reader)
{
Heights = reader.ReadInt16Array();
if (HasHoles(reader.Version))
{
Holes = reader.ReadByteArray();
HolesLOD = reader.ReadByteArray();
EnableHolesTextureCompression = reader.ReadBoolean();
}
if (HasAlign(reader.Version))
{
reader.AlignStream();
}
if (HasShifts(reader.Version))
{
Shifts = reader.ReadAssetArray <Shift>();
reader.AlignStream();
}
PrecomputedError = reader.ReadSingleArray();
MinMaxPatchHeights = reader.ReadSingleArray();
if (HasDefaultPhysicMaterial(reader.Version))
{
DefaultPhysicMaterial.Read(reader);
}
if (HasWidth(reader.Version))
{
Width = reader.ReadInt32();
Height = reader.ReadInt32();
}
if (HasThickness(reader.Version))
{
Thickness = reader.ReadSingle();
}
if (HasResolution(reader.Version))
{
Resolution = reader.ReadInt32();
}
Levels = reader.ReadInt32();
Scale.Read(reader);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
Script = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
if (IsReadPath(reader.Version))
{
PathName = reader.ReadString();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
IsLoop = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
AudioClip.Read(reader);
m_movieData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
ColorSpace = reader.ReadInt32();
}
public void Read(AssetReader reader)
{
Texture.Read(reader);
if (IsReadAlphaTexture(reader.Version))
{
AlphaTexture.Read(reader);
}
if (IsReadSecondaryTextures(reader.Version))
{
m_secondaryTextures = reader.ReadAssetArray <SecondarySpriteTexture>();
}
if (IsReadVertices(reader.Version))
{
m_vertices = reader.ReadAssetArray <SpriteVertex>();
m_indices = reader.ReadUInt16Array();
reader.AlignStream(AlignType.Align4);
}
else
{
m_subMeshes = reader.ReadAssetArray <SubMesh>();
m_indexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
VertexData.Read(reader);
}
if (IsReadBindpose(reader.Version))
{
m_bindpose = reader.ReadAssetArray <Matrix4x4f>();
}
if (IsReadSourceSkin(reader.Version))
{
m_sourceSkin = reader.ReadAssetArray <BoneWeights4>();
}
TextureRect.Read(reader);
TextureRectOffset.Read(reader);
if (IsReadAtlasRectOffset(reader.Version))
{
AtlasRectOffset.Read(reader);
}
SettingsRaw = reader.ReadUInt32();
if (IsReadUVTransform(reader.Version))
{
UVTransform.Read(reader);
}
if (IsReadDownscaleMultiplier(reader.Version))
{
DownscaleMultiplier = reader.ReadSingle();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
m_PVSData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
m_scenes = reader.ReadAssetArray <OcclusionScene>();
if (IsReadStaticRenderers(reader.Flags))
{
m_staticRenderers = reader.ReadAssetArray <SceneObjectIdentifier>();
m_portals = reader.ReadAssetArray <SceneObjectIdentifier>();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
Scene.Read(reader);
m_lightmaps = reader.ReadAssetArray <LightmapData>();
reader.AlignStream(AlignType.Align4);
if (IsReadAOTextures(reader.Version))
{
m_AOTextures = reader.ReadAssetArray <PPtr <Texture2D> >();
}
if (IsReadLightmapsCacheFiles(reader.Version))
{
m_lightmapsCacheFiles = reader.ReadStringArray();
}
LightProbes.Read(reader);
LightmapsMode = reader.ReadInt32();
BakedAmbientProbeInLinear.Read(reader);
m_lightmappedRendererData = reader.ReadAssetArray <RendererData>();
reader.AlignStream(AlignType.Align4);
m_lightmappedRendererDataIDs = reader.ReadAssetArray <SceneObjectIdentifier>();
reader.AlignStream(AlignType.Align4);
EnlightenSceneMapping.Read(reader);
m_enlightenSceneMappingRendererIDs = reader.ReadAssetArray <SceneObjectIdentifier>();
reader.AlignStream(AlignType.Align4);
m_lights = reader.ReadAssetArray <SceneObjectIdentifier>();
reader.AlignStream(AlignType.Align4);
m_lightBakingOutputs = reader.ReadAssetArray <LightBakingOutput>();
reader.AlignStream(AlignType.Align4);
if (IsReadBakedReflectionProbeCubemapCacheFiles(reader.Version))
{
m_bakedReflectionProbeCubemapCacheFiles = reader.ReadStringArray();
}
m_bakedReflectionProbeCubemaps = reader.ReadAssetArray <PPtr <Texture> >();
m_bakedReflectionProbes = reader.ReadAssetArray <SceneObjectIdentifier>();
reader.AlignStream(AlignType.Align4);
m_enlightenData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
EnlightenDataVersion = reader.ReadInt32();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
PVSData = reader.ReadByteArray();
reader.AlignStream();
Scenes = reader.ReadAssetArray <OcclusionScene>();
if (HasStaticRenderers(reader.Flags))
{
StaticRenderers = reader.ReadAssetArray <SceneObjectIdentifier>();
Portals = reader.ReadAssetArray <SceneObjectIdentifier>();
}
}
public void Read(AssetReader reader)
{
name = reader.ReadString();
// TODO cbs
reader.ReadInt32();
// TODO textures
reader.ReadInt32();
// TODO builtinSamplers
reader.ReadInt32();
// TODO inBuffers
reader.ReadInt32();
m_outBuffers = reader.ReadAssetArray <ComputeShaderResource>();
code = reader.ReadByteArray();
disassemblyTxt = D3DCompiler.D3DCompiler.DisassembleToText(code);
threadGroupSize = reader.ReadInt32Array();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (HasReadPVSData(reader.Version))
{
PVSData = reader.ReadByteArray();
reader.AlignStream();
}
if (HasQueryMode(reader.Version))
{
QueryMode = reader.ReadInt32();
}
if (HasOcclusionBakeSettings(reader.Version, reader.Flags))
{
if (IsOcclusionBakeSettingsFirst(reader.Version))
{
OcclusionBakeSettings.Read(reader);
}
}
if (HasSceneGUID(reader.Version))
{
SceneGUID.Read(reader);
OcclusionCullingData.Read(reader);
}
if (HasStaticRenderers(reader.Version, reader.Flags))
{
StaticRenderers = reader.ReadAssetArray <PPtr <Renderer> >();
}
if (HasPortals(reader.Version, reader.Flags))
{
Portals = reader.ReadAssetArray <PPtr <OcclusionPortal> >();
}
if (HasViewCellSize(reader.Version, reader.Flags))
{
ViewCellSize = reader.ReadSingle();
}
if (HasOcclusionBakeSettings(reader.Version, reader.Flags))
{
if (!IsOcclusionBakeSettingsFirst(reader.Version))
{
OcclusionBakeSettings.Read(reader);
}
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadPVSData(reader.Version))
{
m_PVSData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
if (IsReadQueryMode(reader.Version))
{
QueryMode = reader.ReadInt32();
}
if (IsReadOcclusionBakeSettings(reader.Version, reader.Flags))
{
if (IsReadOcclusionBakeSettingsFirst(reader.Version))
{
OcclusionBakeSettings.Read(reader);
}
}
if (IsReadSceneGUID(reader.Version))
{
SceneGUID.Read(reader);
OcclusionCullingData.Read(reader);
}
if (IsReadStaticRenderers(reader.Version, reader.Flags))
{
m_staticRenderers = reader.ReadArray <PPtr <Renderer> >();
}
if (IsReadPortals(reader.Version, reader.Flags))
{
m_portals = reader.ReadArray <PPtr <OcclusionPortal> >();
}
if (IsReadOcclusionBakeSettings(reader.Version, reader.Flags))
{
if (!IsReadOcclusionBakeSettingsFirst(reader.Version))
{
OcclusionBakeSettings.Read(reader);
}
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadLoadType(reader.Version))
{
LoadType = (AudioClipLoadType)reader.ReadInt32();
Channels = reader.ReadInt32();
Frequency = reader.ReadInt32();
BitsPerSample = reader.ReadInt32();
Length = reader.ReadSingle();
if (IsReadIsTrackerFormat(reader.Version))
{
IsTrackerFormat = reader.ReadBoolean();
}
if (IsReadAmbisonic(reader.Version))
{
Ambisonic = reader.ReadBoolean();
}
if (IsAlignTrackerFormat(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadAudioClipFlags(reader.Version))
{
AudioClipFlags = reader.ReadInt32();
}
if (IsReadFSBResourceFirst(reader.Version))
{
FSBResource.Read(reader);
}
SubsoundIndex = reader.ReadInt32();
PreloadAudioData = reader.ReadBoolean();
LoadInBackground = reader.ReadBoolean();
Legacy3D = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
if (!IsReadFSBResourceFirst(reader.Version))
{
FSBResource.Read(reader);
}
if (IsReadType(reader.Version))
{
Type = (FMODSoundType)reader.ReadInt32();
}
if (IsReadCompressionFormat(reader.Version))
{
CompressionFormat = (AudioCompressionFormat)reader.ReadInt32();
}
reader.AlignStream(AlignType.Align4);
#if UNIVERSAL
if (IsReadEditorResource(reader.Flags))
{
EditorResource.Read(reader);
if (IsReadCompressionFormat(reader.Version))
{
EditorCompressionFormat = (AudioCompressionFormat)reader.ReadInt32();
}
}
#endif
}
else
{
if (IsReadDecompressOnLoadFirst(reader.Version))
{
DecompressOnLoad = reader.ReadBoolean();
}
Format = (FMODSoundFormat)reader.ReadInt32();
if (IsReadType(reader.Version))
{
Type = (FMODSoundType)reader.ReadInt32();
}
if (IsReadLength(reader.Version))
{
Length = reader.ReadSingle();
Frequency = reader.ReadInt32();
Size = reader.ReadInt32();
}
if (IsReadDecompressOnLoadSecond(reader.Version))
{
DecompressOnLoad = reader.ReadBoolean();
}
if (IsRead3D(reader.Version))
{
Legacy3D = reader.ReadBoolean();
}
if (IsReadUseHardware(reader.Version))
{
UseHardware = reader.ReadBoolean();
}
if (IsAlignBools(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsStreamInt32(reader.Version))
{
LoadType = (AudioClipLoadType)reader.ReadInt32();
}
if (IsReadStreamingInfo(reader.Version))
{
bool isInnerData = true;
if (LoadType == AudioClipLoadType.Streaming)
{
using (ResourcesFile res = File.Collection.FindResourcesFile(File, StreamingFileName))
{
isInnerData = res == null;
}
}
if (isInnerData)
{
m_audioData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
else
{
StreamingInfo.Read(reader, StreamingFileName);
}
}
else
{
m_audioData = reader.ReadByteArray();
if (IsAlignAudioData(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadDecompressOnLoadThird(reader.Version))
{
DecompressOnLoad = reader.ReadBoolean();
}
if (IsReadStream(reader.Version))
{
if (!IsStreamInt32(reader.Version))
{
LoadType = reader.ReadBoolean() ? AudioClipLoadType.CompressedInMemory : AudioClipLoadType.DecompressOnLoad;
}
}
}
}
public override void Read(AssetReader reader)
{
if (IsSerialized(reader.Version))
{
ReadBase(reader);
ParsedForm.Read(reader);
m_platforms = reader.ReadEnum32Array((t) => (GPUPlatform)t);
uint[] offsets = reader.ReadUInt32Array();
uint[] compressedLengths = reader.ReadUInt32Array();
uint[] decompressedLengths = reader.ReadUInt32Array();
byte[] compressedBlob = reader.ReadByteArray();
reader.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 (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(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 (AssetReader blobReader = new AssetReader(blobMem, reader.Version, reader.Platform, reader.Flags))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob();
blob.Read(blobReader);
m_subProgramBlobs[i] = blob;
}
}
}
}
}
else
{
base.Read(reader);
if (IsEncoded(reader.Version))
{
uint decompressedSize = reader.ReadUInt32();
int comressedSize = reader.ReadInt32();
byte[] subProgramBlob = new byte[comressedSize];
reader.Read(subProgramBlob, 0, comressedSize);
reader.AlignStream(AlignType.Align4);
if (comressedSize > 0 && decompressedSize > 0)
{
byte[] decompressedBuffer = new byte[decompressedSize];
using (MemoryStream memStream = new MemoryStream(subProgramBlob))
{
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(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 (AssetReader blobReader = new AssetReader(memStream, reader.Version, reader.Platform, reader.Flags))
{
SubProgramBlob.Read(blobReader);
}
}
}
}
if (IsReadFallback(reader.Version))
{
Fallback.Read(reader);
}
if (IsReadDefaultProperties(reader.Version))
{
DefaultProperties.Read(reader);
}
if (IsReadStaticProperties(reader.Version))
{
StaticProperties.Read(reader);
}
}
if (IsReadDependencies(reader.Version))
{
m_dependencies = reader.ReadAssetArray <PPtr <Shader> >();
}
if (IsReadNonModifiableTextures(reader.Version))
{
m_nonModifiableTextures = reader.ReadAssetArray <PPtr <Texture> >();
}
if (IsReadShaderIsBaked(reader.Version))
{
ShaderIsBaked = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
#if UNIVERSAL
if (IsReadAlphaIsTransparency(reader.Version, reader.Flags))
{
if (GetAlphaIsTransparencyPosition(reader.Version) == 0)
{
AlphaIsTransparency = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
}
#endif
Width = reader.ReadInt32();
Height = reader.ReadInt32();
CompleteImageSize = reader.ReadInt32();
TextureFormat = (TextureFormat)reader.ReadInt32();
if (IsBoolMinMap(reader.Version))
{
bool mipMap = reader.ReadBoolean();
if (mipMap)
{
int maxSide = Math.Max(Width, Height);
MipCount = Convert.ToInt32(Math.Log(maxSide) / Math.Log(2));
}
else
{
MipCount = 1;
}
}
else
{
MipCount = reader.ReadInt32();
}
if (IsReadIsReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
}
if (IsReadReadAllowed(reader.Version))
{
ReadAllowed = reader.ReadBoolean();
}
if (IsReadStreamingMipmaps(reader.Version))
{
StreamingMipmaps = reader.ReadBoolean();
}
#if UNIVERSAL
if (IsReadAlphaIsTransparency(reader.Version, reader.Flags))
{
if (GetAlphaIsTransparencyPosition(reader.Version) == 1)
{
AlphaIsTransparency = reader.ReadBoolean();
}
}
#endif
reader.AlignStream(AlignType.Align4);
if (IsReadStreamingMipmapsPriority(reader.Version))
{
StreamingMipmapsPriority = reader.ReadInt32();
#if UNIVERSAL
if (IsReadAlphaIsTransparency(reader.Version, reader.Flags))
{
if (GetAlphaIsTransparencyPosition(reader.Version) == 2)
{
AlphaIsTransparency = reader.ReadBoolean();
}
}
#endif
reader.AlignStream(AlignType.Align4);
}
ImageCount = reader.ReadInt32();
TextureDimension = (TextureDimension)reader.ReadInt32();
TextureSettings.Read(reader);
if (IsReadLightmapFormat(reader.Version))
{
LightmapFormat = (TextureUsageMode)reader.ReadInt32();
}
if (IsReadColorSpace(reader.Version))
{
ColorSpace = (ColorSpace)reader.ReadInt32();
}
m_imageData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
if (IsReadStreamData(reader.Version))
{
StreamData.Read(reader);
}
}
public void Read(AssetReader reader)
{
int magic = reader.ReadInt32();
if (magic != GetMagicNumber(reader.Version))
{
throw new Exception($"Magic number {magic} doesn't match");
}
ProgramType = (ShaderGpuProgramType)reader.ReadInt32();
int unknown1 = reader.ReadInt32();
int unknown2 = reader.ReadInt32();
int unknown3 = reader.ReadInt32();
if (HasUnknown4(reader.Version))
{
int unknown4 = reader.ReadInt32();
}
GlobalKeywords = reader.ReadStringArray();
if (HasLocalKeywords(reader.Version))
{
LocalKeywords = reader.ReadStringArray();
}
ProgramData = reader.ReadByteArray();
reader.AlignStream();
int sourceMap = reader.ReadInt32();
int bindCount = reader.ReadInt32();
ShaderBindChannel[] channels = new ShaderBindChannel[bindCount];
for (int i = 0; i < bindCount; i++)
{
ShaderChannel source = (ShaderChannel)reader.ReadUInt32();
VertexComponent target = (VertexComponent)reader.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 <VectorParameter> structVectors = new List <VectorParameter>();
List <MatrixParameter> structMatrices = new List <MatrixParameter>();
List <BufferBinding> buffers = new List <BufferBinding>();
List <UAVParameter> uavs = HasUAVParameters(reader.Version) ? new List <UAVParameter>() : null;
List <SamplerParameter> samplers = HasSamplerParameters(reader.Version) ? new List <SamplerParameter>() : null;
List <BufferBinding> constBindings = new List <BufferBinding>();
List <StructParameter> structs = new List <StructParameter>();
int paramGroupCount = reader.ReadInt32();
ConstantBuffers = new ConstantBuffer[paramGroupCount - 1];
for (int i = 0; i < paramGroupCount; i++)
{
vectors.Clear();
matrices.Clear();
structs.Clear();
string name = reader.ReadString();
int usedSize = reader.ReadInt32();
int paramCount = reader.ReadInt32();
for (int j = 0; j < paramCount; j++)
{
string paramName = reader.ReadString();
ShaderParamType paramType = (ShaderParamType)reader.ReadInt32();
int rows = reader.ReadInt32();
int columns = reader.ReadInt32();
bool isMatrix = reader.ReadInt32() > 0;
int arraySize = reader.ReadInt32();
int index = reader.ReadInt32();
if (isMatrix)
{
MatrixParameter matrix = IsAllParamArgs(reader.Version) ?
new MatrixParameter(paramName, paramType, index, arraySize, rows, columns) :
new MatrixParameter(paramName, paramType, index, rows, columns);
matrices.Add(matrix);
}
else
{
VectorParameter vector = IsAllParamArgs(reader.Version) ?
new VectorParameter(paramName, paramType, index, arraySize, columns) :
new VectorParameter(paramName, paramType, index, columns);
vectors.Add(vector);
}
}
if (HasStructParameters(reader.Version))
{
int structCount = reader.ReadInt32();
for (int j = 0; j < structCount; j++)
{
structVectors.Clear();
structMatrices.Clear();
string structName = reader.ReadString();
int index = reader.ReadInt32();
int arraySize = reader.ReadInt32();
int structSize = reader.ReadInt32();
int strucParamCount = reader.ReadInt32();
for (int k = 0; k < strucParamCount; k++)
{
string paramName = reader.ReadString();
paramName = $"{structName}.{paramName}";
ShaderParamType paramType = (ShaderParamType)reader.ReadInt32();
int rows = reader.ReadInt32();
int columns = reader.ReadInt32();
bool isMatrix = reader.ReadInt32() > 0;
int vectorArraySize = reader.ReadInt32();
int paramIndex = reader.ReadInt32();
if (isMatrix)
{
MatrixParameter matrix = IsAllParamArgs(reader.Version) ?
new MatrixParameter(paramName, paramType, paramIndex, vectorArraySize, rows, columns) :
new MatrixParameter(paramName, paramType, paramIndex, rows, columns);
structMatrices.Add(matrix);
}
else
{
VectorParameter vector = IsAllParamArgs(reader.Version) ?
new VectorParameter(paramName, paramType, paramIndex, vectorArraySize, columns) :
new VectorParameter(paramName, paramType, paramIndex, columns);
structVectors.Add(vector);
}
}
StructParameter @struct = new StructParameter(structName, index, arraySize, structSize, structVectors.ToArray(), structMatrices.ToArray());
structs.Add(@struct);
}
}
if (i == 0)
{
VectorParameters = vectors.ToArray();
MatrixParameters = matrices.ToArray();
StructParameters = structs.ToArray();
}
else
{
ConstantBuffer constBuffer = new ConstantBuffer(name, matrices.ToArray(), vectors.ToArray(), structs.ToArray(), usedSize);
ConstantBuffers[i - 1] = constBuffer;
}
}
int paramGroup2Count = reader.ReadInt32();
for (int i = 0; i < paramGroup2Count; i++)
{
string name = reader.ReadString();
int type = reader.ReadInt32();
int index = reader.ReadInt32();
int extraValue = reader.ReadInt32();
if (type == 0)
{
TextureParameter texture;
if (HasMultiSampled(reader.Version))
{
uint textureExtraValue = reader.ReadUInt32();
bool isMultiSampled = (textureExtraValue & 1) == 1;
byte dimension = (byte)(textureExtraValue >> 1);
texture = new TextureParameter(name, index, dimension, extraValue, isMultiSampled);
}
else
{
byte dimension = unchecked ((byte)extraValue);
int samplerIndex = extraValue >> 8;
if (samplerIndex == 0xFFFFFF)
{
samplerIndex = -1;
}
texture = new TextureParameter(name, index, dimension, samplerIndex);
}
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 && HasUAVParameters(reader.Version))
{
UAVParameter uav = new UAVParameter(name, index, extraValue);
uavs.Add(uav);
}
else if (type == 4 && HasSamplerParameters(reader.Version))
{
SamplerParameter sampler = new SamplerParameter((uint)extraValue, index);
samplers.Add(sampler);
}
else
{
throw new Exception($"Unupported parameter type {type}");
}
}
TextureParameters = textures.ToArray();
BufferParameters = buffers.ToArray();
if (HasUAVParameters(reader.Version))
{
UAVParameters = uavs.ToArray();
}
if (HasSamplerParameters(reader.Version))
{
SamplerParameters = samplers.ToArray();
}
ConstantBufferBindings = constBindings.ToArray();
if (HasStructParameters(reader.Version))
{
StructParameters = structs.ToArray();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadLODData(reader.Version))
{
m_LODData = reader.ReadArray <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.ReadArray <SubMesh>();
}
if (IsReadBlendShapes(reader.Version))
{
Shapes.Read(reader);
}
if (IsReadBindPosesFirst(reader.Version))
{
m_bindPoses = reader.ReadArray <Matrix4x4f>();
}
if (IsReadBoneNameHashes(reader.Version))
{
m_boneNameHashes = reader.ReadUInt32Array();
RootBoneNameHash = reader.ReadUInt32();
}
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 = reader.ReadInt32();
}
}
else
{
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.ReadArray <Vector3f>();
}
}
else
{
m_vertices = reader.ReadArray <Vector3f>();
}
}
if (IsReadSkin(reader.Version))
{
m_skin = reader.ReadArray <BoneWeights4>();
}
if (IsReadBindPoses(reader.Version))
{
if (!IsReadBindPosesFirst(reader.Version))
{
m_bindPoses = reader.ReadArray <Matrix4x4f>();
}
}
if (IsReadVertexData(reader.Version))
{
if (IsReadOnlyVertexData(reader.Version))
{
VertexData.Read(reader);
}
else
{
if (MeshCompression == 0)
{
VertexData.Read(reader);
}
else
{
m_UV = reader.ReadArray <Vector2f>();
m_UV1 = reader.ReadArray <Vector2f>();
m_tangents = reader.ReadArray <Vector4f>();
m_normals = reader.ReadArray <Vector3f>();
m_colors = reader.ReadArray <ColorRGBA32>();
}
}
}
else
{
m_UV = reader.ReadArray <Vector2f>();
if (IsReadUV1(reader.Version))
{
m_UV1 = reader.ReadArray <Vector2f>();
}
if (IsReadTangentSpace(reader.Version))
{
m_tangentSpace = reader.ReadArray <Tangent>();
}
else
{
m_tangents = reader.ReadArray <Vector4f>();
m_normals = reader.ReadArray <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.ReadArray <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 (IsReadStreamData(reader.Version))
{
StreamData.Read(reader);
}
}
public override void Read(AssetReader reader)
{
if (IsSerialized(reader.Version))
{
ReadNamedObject(reader);
ParsedForm.Read(reader);
Platforms = reader.ReadArray((t) => (GPUPlatform)t);
if (IsDoubleArray(reader.Version))
{
uint[][] offsets = reader.ReadUInt32ArrayArray();
uint[][] compressedLengths = reader.ReadUInt32ArrayArray();
uint[][] decompressedLengths = reader.ReadUInt32ArrayArray();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream();
UnpackSubProgramBlobs(reader.Layout, offsets, compressedLengths, decompressedLengths, compressedBlob);
}
else
{
uint[] offsets = reader.ReadUInt32Array();
uint[] compressedLengths = reader.ReadUInt32Array();
uint[] decompressedLengths = reader.ReadUInt32Array();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream();
UnpackSubProgramBlobs(reader.Layout, offsets, compressedLengths, decompressedLengths, compressedBlob);
}
}
else
{
base.Read(reader);
if (HasBlob(reader.Version))
{
uint decompressedSize = reader.ReadUInt32();
byte[] compressedBlob = reader.ReadByteArray();
reader.AlignStream();
UnpackSubProgramBlobs(reader.Layout, 0, (uint)compressedBlob.Length, decompressedSize, compressedBlob);
}
if (HasFallback(reader.Version))
{
Fallback.Read(reader);
}
if (HasDefaultProperties(reader.Version))
{
DefaultProperties.Read(reader);
}
if (HasStaticProperties(reader.Version))
{
StaticProperties.Read(reader);
}
}
if (HasDependencies(reader.Version))
{
Dependencies = reader.ReadAssetArray <PPtr <Shader> >();
}
if (HasNonModifiableTextures(reader.Version))
{
NonModifiableTextures = new Dictionary <string, PPtr <Texture> >();
NonModifiableTextures.Read(reader);
}
if (HasShaderIsBaked(reader.Version))
{
ShaderIsBaked = reader.ReadBoolean();
reader.AlignStream();
}
#if UNIVERSAL
if (HasErrors(reader.Version, reader.Flags))
{
Errors = reader.ReadAssetArray <ShaderError>();
}
if (HasDefaultTextures(reader.Version, reader.Flags))
{
DefaultTextures = new Dictionary <string, PPtr <Texture> >();
DefaultTextures.Read(reader);
}
if (HasCompileInfo(reader.Version, reader.Flags))
{
CompileInfo.Read(reader);
}
#endif
}
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.ReadTupleIntFloatArray();
}
}
ConvertCase = reader.ReadInt32();
if (!IsReadFontImpl(reader.Version))
{
DefaultMaterial.Read(reader);
}
m_characterRects = reader.ReadArray <CharacterInfo>();
if (!IsReadFontImpl(reader.Version))
{
Texture.Read(reader);
}
if (IsReadGridFont(reader.Version))
{
if (IsGridFontFirst(reader.Version))
{
GridFont = reader.ReadBoolean();
}
}
if (IsByteKerningValues(reader.Version))
{
m_kerningValuesByte = new Dictionary <Tuple <byte, byte>, float>();
m_kerningValuesByte.Read(reader);
}
else
{
m_kerningValues.Read(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.ReadArray <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)
{
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 override void Read(AssetReader reader)
{
base.Read(reader);
if (HasLODData(reader.Version))
{
LODData = reader.ReadAssetArray <LOD>();
}
else
{
if (HasUse16bitIndices(reader.Version))
{
Use16BitIndices = reader.ReadUInt32();
}
if (IsIndexBufferFirst(reader.Version))
{
IndexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
SubMeshes = reader.ReadAssetArray <SubMesh>();
}
if (HasBlendShapes(reader.Version))
{
if (HasBlendChannels(reader.Version))
{
Shapes.Read(reader);
}
else
{
BlendShapes = reader.ReadAssetArray <BlendShape>();
reader.AlignStream(AlignType.Align4);
ShapeVertices = reader.ReadAssetArray <BlendShapeVertex>();
}
}
if (HasBindPose(reader.Version))
{
if (IsBindPoseFirst(reader.Version))
{
BindPose = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (HasBoneNameHashes(reader.Version))
{
BoneNameHashes = reader.ReadUInt32Array();
RootBoneNameHash = reader.ReadUInt32();
}
if (HasBonesAABB(reader.Version))
{
BonesAABB = reader.ReadAssetArray <MinMaxAABB>();
VariableBoneCountWeights.Read(reader);
}
if (HasMeshCompression(reader.Version))
{
MeshCompression = (MeshCompression)reader.ReadByte();
}
if (HasStreamCompression(reader.Version))
{
StreamCompression = reader.ReadByte();
}
if (HasIsReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
KeepVertices = reader.ReadBoolean();
KeepIndices = reader.ReadBoolean();
}
if (IsAlignFlags(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (HasIndexFormat(reader.Version))
{
if (IsIndexFormatCondition(reader.Version))
{
if (MeshCompression == MeshCompression.Off)
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
else
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
if (!HasLODData(reader.Version))
{
if (!IsIndexBufferFirst(reader.Version))
{
IndexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (HasVertexData(reader.Version))
{
if (!IsOnlyVertexData(reader.Version))
{
if (MeshCompression != MeshCompression.Off)
{
Vertices = reader.ReadAssetArray <Vector3f>();
}
}
}
else
{
Vertices = reader.ReadAssetArray <Vector3f>();
}
if (HasSkin(reader.Version))
{
Skin = reader.ReadAssetArray <BoneWeights4>();
}
if (HasBindPose(reader.Version))
{
if (!IsBindPoseFirst(reader.Version))
{
BindPose = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (HasVertexData(reader.Version))
{
if (IsOnlyVertexData(reader.Version))
{
VertexData.Read(reader);
}
else
{
if (MeshCompression == MeshCompression.Off)
{
VertexData.Read(reader);
}
else
{
UV = reader.ReadAssetArray <Vector2f>();
UV1 = reader.ReadAssetArray <Vector2f>();
Tangents = reader.ReadAssetArray <Vector4f>();
Normals = reader.ReadAssetArray <Vector3f>();
Colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
}
else
{
UV = reader.ReadAssetArray <Vector2f>();
if (HasUV1(reader.Version))
{
UV1 = reader.ReadAssetArray <Vector2f>();
}
if (HasTangentSpace(reader.Version))
{
TangentSpace = reader.ReadAssetArray <Tangent>();
}
else
{
Tangents = reader.ReadAssetArray <Vector4f>();
Normals = reader.ReadAssetArray <Vector3f>();
}
}
if (IsAlignVertex(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (HasCompressedMesh(reader.Version))
{
CompressedMesh.Read(reader);
}
LocalAABB.Read(reader);
if (!HasVertexData(reader.Version))
{
Colors = reader.ReadAssetArray <ColorRGBA32>();
}
if (HasCollisionTriangles(reader.Version))
{
CollisionTriangles = reader.ReadUInt32Array();
CollisionVertexCount = reader.ReadInt32();
}
if (HasMeshUsageFlags(reader.Version))
{
MeshUsageFlags = reader.ReadInt32();
}
if (HasCollision(reader.Version))
{
CollisionData.Read(reader);
}
if (HasMeshMetrics(reader.Version))
{
MeshMetrics = new float[2];
MeshMetrics[0] = reader.ReadSingle();
MeshMetrics[1] = reader.ReadSingle();
}
#if UNIVERSAL
if (HasMeshOptimization(reader.Version, reader.Flags))
{
if (IsMeshOptimizationFlags(reader.Version))
{
MeshOptimizationFlags = (MeshOptimizationFlags)reader.ReadInt32();
}
else
{
MeshOptimized = reader.ReadBoolean();
}
}
#endif
if (HasStreamData(reader.Version))
{
reader.AlignStream(AlignType.Align4);
StreamData.Read(reader);
}
}