/// <summary>
/// Initalize the Class
/// </summary>
/// <param name="fileStream">Stream of the STFS Container</param>
private void Initalize(Stream fileStream)
{
_stfsStream = new EndianStream(fileStream, Endian.BigEndian);
LoadHeader();
LoadMetaData();
LoadFileListing();
LoadEmbeddedFilesFromFileListing();
LoadBlockTable();
}
public override void Read(EndianStream stream)
{
base.Read(stream);
LocalRotation.Read(stream);
LocalPosition.Read(stream);
LocalScale.Read(stream);
m_children = stream.ReadArray(() => new PPtr <Transform>(AssetsFile));
Father.Read(stream);
}
public void Update(EndianStream stream)
{
stream.SeekTo(Offset);
stream.WriteInt32(Ident);
stream.WriteByte(RunTimeMinimium);
stream.WriteByte(RunTimeMaximium);
stream.WriteByte(CountOnMap);
stream.WriteByte(DesignTimeMaximium);
stream.WriteFloat(Cost);
}
public void Read(EndianStream stream)
{
ID = stream.ReadUInt32();
TypeID = stream.ReadUInt32();
if (IsReadType)
{
Type = stream.ReadUInt32();
}
Index = stream.ReadUInt32();
}
public override void Read(EndianStream stream)
{
base.Read(stream);
Components = stream.ReadArray(() => new ComponentPair(AssetsFile));
Layer = stream.ReadInt32();
Name = stream.ReadStringAligned();
Tag = stream.ReadUInt16();
IsActive = stream.ReadBoolean();
}
public void Read(EndianStream stream)
{
m_weight[0] = stream.ReadSingle();
m_weight[1] = stream.ReadSingle();
m_weight[2] = stream.ReadSingle();
m_weight[3] = stream.ReadSingle();
m_boneIndex[0] = stream.ReadInt32();
m_boneIndex[1] = stream.ReadInt32();
m_boneIndex[2] = stream.ReadInt32();
m_boneIndex[3] = stream.ReadInt32();
}
private void ParseBundleStreaming(EndianStream stream)
{
if (IsBundleFormat6)
{
ParseBundleFormat6(stream, false);
}
else
{
throw new NotImplementedException($"Streaming asset bundle with format {Format}");
}
}
public void Load(EndianStream stream, MapMetaData mapMetaData)
{
Offset = stream.Position;
Ident = stream.ReadInt32();
Tag = mapMetaData.GetTag(Ident);
RunTimeMinimium = stream.ReadByte();
RunTimeMaximium = stream.ReadByte();
CountOnMap = stream.ReadByte();
DesignTimeMaximium = stream.ReadByte();
Cost = stream.ReadFloat();
}
public void Read(EndianStream stream)
{
NameIndex = stream.ReadInt32();
m_matrixParams = stream.ReadArray <MatrixParameter>();
m_vectorParams = stream.ReadArray <VectorParameter>();
if (IsReadStructParams)
{
m_structParams = stream.ReadArray <StructParameter>();
}
Size = stream.ReadInt32();
}
private void Initalize(Stream blfStream)
{
_blfStream = new EndianStream(blfStream, Endian.BigEndian);
if (!isValidBLF())
{
throw new Exception("Invalid BLF Container!");
}
LoadChunkTable();
}
public void Read(EndianStream stream)
{
Name = stream.ReadStringAligned();
ParamType = (ShaderParamType)stream.ReadInt32();
Rows = stream.ReadInt32();
Dimension = stream.ReadInt32();
IsMatrix = stream.ReadInt32() > 0;
int unknown = stream.ReadInt32();
Index = stream.ReadInt32();
}
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)
{
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);
}
protected void ProcessMapHeader()
{
using (IReader reader = new EndianStream(new MemoryStream(MapHeader), Endian.LittleEndian))
{
reader.SeekTo(MapTypeOffset);
MapType = (CacheFileType)reader.ReadInt32();
reader.SeekTo(MapNameOffset);
MapName = reader.ReadAscii();
}
}
public void Read(EndianStream stream)
{
NameIndex = stream.ReadInt32();
Index = stream.ReadInt32();
ArraySize = stream.ReadInt32();
StructSize = stream.ReadInt32();
m_vectorMembers = stream.ReadArray <VectorParameter>();
stream.AlignStream(AlignType.Align4);
m_matrixMembers = stream.ReadArray <MatrixParameter>();
stream.AlignStream(AlignType.Align4);
}
public void Read(Stream baseStream, Action <string> requestDependencyCallback)
{
using (EndianStream stream = new EndianStream(baseStream, baseStream.Position, EndianType.BigEndian))
{
long startPosition = baseStream.Position;
Header.Read(stream);
stream.EndianType = Header.Endianess ? EndianType.BigEndian : EndianType.LittleEndian;
if (IsTableAtTheEnd(Header.Generation))
{
stream.BaseStream.Position = startPosition + Header.FileSize - Header.MetadataSize;
stream.BaseStream.Position++;
}
using (SerializedFileStream fileStream = new SerializedFileStream(stream, Header.Generation))
{
Metadata.Read(fileStream);
}
foreach (FileIdentifier dependency in Dependencies)
{
requestDependencyCallback?.Invoke(dependency.FilePath);
}
if (RTTIClassHierarchyDescriptor.IsReadSignature(Header.Generation))
{
ReadAssets(stream, startPosition);
}
else
{
Logger.Log(LogType.Warning, LogCategory.Import, $"Can't determine file version for generation {Header.Generation} for file '{Name}'");
string[] versions = GetGenerationVersions(Header.Generation);
for (int i = 0; i < versions.Length; i++)
{
string version = versions[i];
Logger.Log(LogType.Debug, LogCategory.Import, $"Try parse {nameof(SerializedFile)} as {version} version");
Version.Parse(version);
try
{
ReadAssets(stream, startPosition);
break;
}
catch
{
Logger.Log(LogType.Debug, LogCategory.Import, "Faild");
if (i == versions.Length - 1)
{
throw;
}
}
}
}
}
}
public void Read(EndianStream stream)
{
Time = stream.ReadSingle();
FunctionName = stream.ReadStringAligned();
StringParameter = stream.ReadStringAligned();
ObjectReferenceParameter.Read(stream);
FloatParameter = stream.ReadSingle();
IntParameter = stream.ReadInt32();
MessageOptions = stream.ReadInt32();
}
public void Read(EndianStream stream)
{
X.Read(stream);
Type = stream.ReadUInt32();
XMotionType = stream.ReadUInt32();
YMotionType = stream.ReadUInt32();
ZMotionType = stream.ReadUInt32();
MinLimitX = stream.ReadSingle();
MaxLimitX = stream.ReadSingle();
MaxLimitY = stream.ReadSingle();
MaxLimitZ = stream.ReadSingle();
}
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();
}
private void ReadRawWeb(EndianStream stream)
{
if (Generation < BundleGeneration.BF_530_x)
{
ReadPre530Generation(stream);
}
else
{
Read530Generation(stream);
stream.BaseStream.Position++;
}
}
public void Read(EndianStream stream)
{
m_stateConstantArray = stream.ReadArray(() => new OffsetPtr <StateConstant>(new StateConstant(m_assetsFile)));
m_anyStateTransitionConstantArray = stream.ReadArray(() => new OffsetPtr <TransitionConstant>(new TransitionConstant(m_assetsFile)));
if (IsReadConstantArray)
{
m_selectorStateConstantArray = stream.ReadArray(() => new OffsetPtr <SelectorStateConstant>(new SelectorStateConstant()));
}
DefaultState = stream.ReadUInt32();
MotionSetCount = stream.ReadUInt32();
}
public TagEntry(EndianStream stream, Tag mapTags)
{
PlacedItems = new List <ItemPlacementChunk>();
Offset = stream.Position;
Ident = stream.ReadInt32();
Tag = mapTags.SearchTags(Ident);
RunTimeMinimium = stream.ReadByte();
RunTimeMaximium = stream.ReadByte();
CountOnMap = stream.ReadByte();
DesignTimeMaximium = stream.ReadByte();
Cost = stream.ReadFloat();
}
public static bool IsBundleFile(Stream baseStream)
{
using (EndianStream stream = new EndianStream(baseStream, baseStream.Position, EndianType.BigEndian))
{
long position = stream.BaseStream.Position;
string signature = stream.ReadStringZeroTerm();
bool isBundle = BundleHeader.TryParseSignature(signature, out BundleType _);
stream.BaseStream.Position = position;
return(isBundle);
}
}
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)
{
if (IsVector3)
{
Min3.Read(stream);
Max3.Read(stream);
}
else
{
Min4.Read(stream);
Max4.Read(stream);
}
}
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);
}
private void Initalize(Stream shotStream)
{
_shotStream = new EndianStream(shotStream, Endian.BigEndian);
if (!isValidScreen())
{
Close();
throw new Exception("Invalid Halo Reach screenshot!");
}
// Load Screenshot Parts
LoadHeader();
LoadScreenshot();
}
private void Initalize(Stream fileStream)
{
_gpdStream = new EndianStream(fileStream, Endian.BigEndian);
if (!IsValidGPD())
{
Close();
throw new Exception("Invalid Halo 3 GPD!");
}
LoadPlayerVisuals();
LoadCampaignCompletion();
}
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)
{
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 void PassBattle()
{
RelayConnector pRelayConnector = m_RpcConnector.GetRelayConnector();
MessageMeta meta = new MessageMeta(
(UInt32)MSGMETA_TYPE_LIB.MSGMETA_TYPE_LIB_PU_TOGLOBAL,
(UInt32)mln.ROOM_HUB.MSG_ID.MSG_ID_PASS_BATTLE,
m_RoomHubPU_PUUID, // dadr
pRelayConnector.ClientID // sadr
);
// パケット内部情報セット
EndianStream es = new EndianStream();
es.put(m_RpcConnector.GetPUUID());
meta.SetData(es.size(), es.getBuffer());
// 送信
pRelayConnector.Post(meta);
}
protected override void ProcEvent(EVENT i_pEvent)
{
switch ((PU_EVENT)i_pEvent.type)
{
case PU_EVENT.PU_EVENT_NOTIFY_DEREG_GPU:
{ // 接続先の PU の切断通知
EndianStream es = new EndianStream();
es.write(i_pEvent.msg.data(), i_pEvent.msg.size());
PACKET_PNW_GPUINFO data = new PACKET_PNW_GPUINFO();
data.get(es);
OnDisconnectedRPC(data.gpuId, RPCBasePU.DISCONNECT_STATE.DISCONNECT_STATE_RPC);
} break;
case PU_EVENT.PU_EVENT_NOTIFY_DISCONNECTED_SOCKET:
{ // クライアントの切断通知
EndianStream es = new EndianStream();
es.write(i_pEvent.msg.data(), i_pEvent.msg.size());
PACKET_CLC_CONDISCONNECTED data = new PACKET_CLC_CONDISCONNECTED();
data.get(es);
OnDisconnectedRPC(i_pEvent.msg.sadr, RPCBasePU.DISCONNECT_STATE.DISCONNECT_STATE_SOCKET);
} break;
}
}
/// EndianStream から入力する
public void get(EndianStream es)
{
es.get(out puUid );
}
PUUID puUid; // パッシング先のPUUID
/// EndianStream に出力する
public void put(EndianStream es)
{
es.put(puUid);
}
