public override void Write(Vault vault, BinaryWriter bw)
{
_debugNameText.Write(vault, bw);
bw.Write(BlendEnable);
bw.Write(AlphaTestEnable);
bw.AlignWriter(4);
bw.Write(AlphaTestRef);
bw.WriteEnum(AlphaTestFunc);
bw.WriteArray(SourceColor, bw.WriteEnum);
bw.WriteArray(DestColor, bw.WriteEnum);
bw.WriteArray(OperationColor, bw.WriteEnum);
bw.WriteArray(SourceAlpha, bw.WriteEnum);
bw.WriteArray(DestAlpha, bw.WriteEnum);
bw.WriteArray(OperationAlpha, bw.WriteEnum);
BlendFactor.Write(vault, bw);
bw.WriteArray(RGBAEnableRT0, bw.Write);
bw.WriteArray(RGBAEnableRT1, bw.Write);
bw.WriteArray(RGBAEnableRT2, bw.Write);
bw.WriteArray(RGBAEnableRT3, bw.Write);
bw.Write(AlphaToMaskEnable_XENON);
bw.WriteArray(HiPrecisionBlendEnable_XENON, bw.Write);
bw.WriteArray(BlendEnable_PS3, bw.Write);
bw.Write(BlendFactorF16_PS3);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
_debugNameText = new Text(Class, Field, Collection)
{
Value = DebugName
};
_debugNameText.Write(vault, bw);
bw.WriteEnum(CullMode);
bw.Write(DepthBias);
bw.Write(ScaleDepthBias);
bw.Write(ScissorTestEnable);
bw.Write(PrimitiveResetEnable);
bw.AlignWriter(4);
bw.Write(PrimitiveResetIndex);
ScissorData.Write(vault, bw);
bw.WriteEnum(FillMode);
bw.Write(MultiSampleAntialiasEnable);
bw.AlignWriter(4);
bw.Write(MultiSampleMask);
bw.Write(ViewPortEnable);
bw.Write(HalfPixelOffsetEnable);
bw.AlignWriter(4);
bw.WriteEnum(ShadeMode);
bw.WriteEnum(FrontFace);
}
public override void WritePointerData(Vault vault, BinaryWriter bw)
{
foreach (var baseField in Collection.Class.BaseFields)
{
bw.AlignWriter(baseField.Alignment);
if (DestinationLayoutPointer == 0)
{
DestinationLayoutPointer = bw.BaseStream.Position;
}
if (bw.BaseStream.Position - DestinationLayoutPointer != baseField.Offset)
{
throw new Exception("incorrect offset");
}
Collection.GetRawValue(baseField.Name).Write(vault, bw);
}
foreach (var dataPair in Collection.GetData())
{
VltClassField field = Collection.Class[dataPair.Key];
if (!field.IsInLayout)
{
var entry = Entries.First(e => e.Key == field.Key);
if (!(entry.InlineData is IPointerObject pointerObject))
{
continue;
}
bw.AlignWriter(field.Alignment);
pointerObject.WritePointerData(vault, bw);
}
else
{
if (!(dataPair.Value is IPointerObject pointerObject))
{
continue;
}
bw.AlignWriter(field.Alignment);
pointerObject.WritePointerData(vault, bw);
}
}
if (Collection.Class.HasBaseFields)
{
// align to 4 bytes for layout data
bw.AlignWriter(4);
}
else
{
// there is no layout data but we might still be
// in a bad position, so align to 2 bytes
bw.AlignWriter(2);
}
}
public override void Write(Vault vault, BinaryWriter bw)
{
_actorNameText.Write(vault, bw);
_carChannelNameText.Write(vault, bw);
bw.Write(IsDriver);
bw.AlignWriter(4);
bw.Write(ExitAnimSec);
bw.Write(IsFacePixelation);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.Write(Kit);
bw.AlignWriter(4);
bw.Write(Region);
_srcSlidersPtr = bw.BaseStream.Position;
bw.Write(0);
bw.Write((byte)Sliders.Count);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.WriteEnum(SlotID);
Group.Write(vault, bw);
bw.Write(Swatch);
bw.AlignWriter(4);
bw.Write(Saturation);
bw.Write(Variance);
bw.Write(Unknown);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
ReferencedRow.Write(vault, bw);
bw.Write(IsMember);
bw.AlignWriter(4);
bw.Write(MemberIndex);
bw.Write(IsElement);
bw.AlignWriter(4);
bw.Write(ElementIndex);
bw.WriteEnum(ModificationType);
bw.Write(Value);
}
public void Save(BinaryWriter bw, IList <Vault> vaults, PackSavingOptions savingOptions = null)
{
if (vaults.Count != 1)
{
throw new InvalidDataException("Can only save exactly 1 vault");
}
char[] nameChars = new char[0x2C];
_name.CopyTo(0, nameChars, 0, _name.Length);
VaultWriter vaultWriter = new VaultWriter(vaults[0], new VaultSaveOptions());
vaultWriter.ExportManager.AddExport(new VaultSlotExport());
VaultStreamInfo vaultStreamInfo = vaultWriter.BuildVault();
bw.Write(nameChars);
var binOffsetPos = bw.BaseStream.Position;
bw.Write(0);
bw.Write((uint)vaultStreamInfo.BinStream.Length);
var vltOffsetPos = bw.BaseStream.Position;
bw.Write(0);
bw.Write((uint)vaultStreamInfo.VltStream.Length);
var fileSizePos = bw.BaseStream.Position;
bw.Write(0);
bw.AlignWriter(0x40);
var binOffset = bw.BaseStream.Position;
vaultStreamInfo.BinStream.CopyTo(bw.BaseStream);
bw.AlignWriter(0x40);
var vltOffset = bw.BaseStream.Position;
vaultStreamInfo.VltStream.CopyTo(bw.BaseStream);
//bw.AlignWriter(0x80);
bw.BaseStream.Position = binOffsetPos;
bw.Write((uint)binOffset);
bw.BaseStream.Position = vltOffsetPos;
bw.Write((uint)vltOffset);
bw.BaseStream.Position = fileSizePos;
bw.Write((uint)bw.BaseStream.Length);
bw.BaseStream.Position = bw.BaseStream.Length;
}
public override void WritePointerData(Vault vault, BinaryWriter bw)
{
foreach (var baseField in Collection.Class.BaseFields)
{
bw.AlignWriter(baseField.Alignment);
if (_dstLayoutPtr == 0)
{
_dstLayoutPtr = bw.BaseStream.Position;
}
if (bw.BaseStream.Position - _dstLayoutPtr != baseField.Offset)
{
throw new Exception("incorrect offset");
}
Collection.GetRawValue(baseField.Name).Write(vault, bw);
//Collection.Data[baseField.Name].Write(vault, bw);
}
foreach (var dataPair in Collection.GetData())
{
VltClassField field = Collection.Class[dataPair.Key];
if (!field.IsInLayout)
{
var entry = _entries.First(e => e.Key == field.Key);
if (!(entry.InlineData is IPointerObject pointerObject))
{
continue;
}
bw.AlignWriter(field.Alignment);
pointerObject.WritePointerData(vault, bw);
}
else
{
if (!(dataPair.Value is IPointerObject pointerObject))
{
continue;
}
bw.AlignWriter(field.Alignment);
pointerObject.WritePointerData(vault, bw);
}
}
bw.AlignWriter(Collection.Class.HasBaseFields ? 4 : 2);
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.WriteEnum(AnimType);
bw.Write(FPS);
bw.Write(RandomStartFrame);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.WriteEnum(mPerformanceType);
bw.Write(mInverse);
bw.AlignWriter(4);
bw.Write(mPercentage);
}
public override void Write(Vault vault, BinaryWriter bw)
{
_debugNameText.Write(vault, bw);
bw.Write(TwoSidedStencilMode);
bw.Write(ZEnable);
bw.Write(ZWriteEnable);
bw.Write(StencilEnable);
bw.WriteEnum(ZFunc);
bw.WriteEnum(StencilFunc);
bw.WriteEnum(StencilFuncCCW);
bw.Write(StencilRef);
bw.Write(StencilRefCCW);
bw.Write(StencilMask);
bw.Write(StencilMaskCCW);
bw.Write(StencilWriteMask);
bw.Write(StencilWriteMaskCCW);
bw.WriteEnum(StencilFailOp);
bw.WriteEnum(StencilFailOpCCW);
bw.WriteEnum(StencilZFailOp);
bw.WriteEnum(StencilZFailOpCCW);
bw.WriteEnum(StencilPassOp);
bw.WriteEnum(StencilPassOpCCW);
bw.WriteEnum(HiStencilFunc);
bw.Write(HiStencilRef);
bw.Write(HiStencilEnable);
bw.Write(HiStencilWriteEnable);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.Write(Swatch);
bw.Write(Saturation);
bw.Write(Brightness);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
PhysicsTuningSlider.Write(vault, bw);
bw.Write(CenteredAroundPreset);
bw.AlignWriter(4);
bw.Write(Position);
}
public override void Write(Vault vault, BinaryWriter bw)
{
ReferencedAttribute.Write(vault, bw);
bw.Write(IsMember);
bw.AlignWriter(4);
bw.Write(MemberIndex);
bw.Write(BlendingPower);
}
public void WritePointerData(Vault vault, BinaryWriter bw)
{
foreach (var pointerObject in Items.OfType <IPointerObject>())
{
bw.AlignWriter(ItemAlignment);
pointerObject.WritePointerData(vault, bw);
}
}
public void Write(Vault vault, BinaryWriter bw)
{
bw.Write(Key);
InlineData.Write(vault, bw);
bw.AlignWriter(4);
bw.Write(TypeIndex);
bw.WriteEnum(NodeFlags);
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.Write(PartNameHash);
bw.Write(Mirrored);
bw.AlignWriter(4);
Transform.Write(vault, bw);
Color.Write(vault, bw);
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.Write(PartNameHash);
bw.Write(Mirrored);
bw.AlignWriter(4);
Transform.Write(vault, bw);
for (int i = 0; i < 4; i++)
{
Colors[i].Write(vault, bw);
}
}
public void WritePointerData(Vault vault, BinaryWriter bw)
{
_typeNamesDst = bw.BaseStream.Position;
foreach (var type in vault.Database.Types)
{
NullTerminatedString.Write(bw, type.Name);
}
bw.AlignWriter(8);
}
public void WritePointerData(Vault vault, BinaryWriter bw)
{
bw.AlignWriter(Field.Alignment);
_offsetDst = bw.BaseStream.Position;
Data.Write(vault, bw);
if (Data is IPointerObject pointerObject)
{
pointerObject.WritePointerData(vault, bw);
}
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.WriteEnum(CurveStyle);
bw.Write(CurvePower);
bw.Write(CurveMultiplierLowSpeed);
bw.Write(CurveMultiplierHighSpeed);
bw.Write(InnerDeadZone);
bw.Write(OuterDeadZone);
bw.Write(NumberOfSteps);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.Write(Capacity);
bw.Write((ushort)Items.Count);
bw.Write(FieldSize);
bw.Write((ushort)(1 << (Field.Alignment - 1)));
foreach (var t in Items)
{
bw.AlignWriter(ItemAlignment);
var start = bw.BaseStream.Position;
t.Write(vault, bw);
//if (!(t is PrimitiveTypeBase))
Debug.Assert(bw.BaseStream.Position - start == FieldSize);
}
for (var i = 0; i < Capacity - Items.Count; i++)
{
bw.AlignWriter(ItemAlignment);
bw.Write(new byte[FieldSize]);
}
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.Write(Key);
InlineData.Write(vault, bw);
if (HasInlineFlag())
{
bw.AlignWriter(4);
}
bw.Write(TypeIndex);
bw.Write((byte)NodeFlags);
bw.Write(EntryFlags);
}
public override void WritePointerData(Vault vault, BinaryWriter bw)
{
_dstDefinitionsPtr = bw.BaseStream.Position;
foreach (var field in Class.Fields.Values)
{
AttribDefinition64 definition = new AttribDefinition64();
definition.Key = VLT64Hasher.Hash(field.Name);
definition.Alignment = field.Alignment;
definition.Flags = field.Flags;
definition.MaxCount = field.MaxCount;
definition.Offset = field.Offset;
definition.Size = field.Size;
definition.Type = VLT64Hasher.Hash(field.TypeName);
definition.Write(vault, bw);
}
if (_srcStaticPtr != 0)
{
bw.AlignWriter(0x10);
_dstStaticPtr = bw.BaseStream.Position;
foreach (var staticField in Class.StaticFields)
{
bw.AlignWriter(staticField.Alignment);
staticField.StaticValue.Write(vault, bw);
}
foreach (var staticField in Class.StaticFields)
{
if (staticField.StaticValue is IPointerObject pointerObject)
{
pointerObject.WritePointerData(vault, bw);
}
}
}
}
public override void Write(Vault vault, BinaryWriter bw)
{
bw.Write(HAL_ID);
bw.Write(CF_HAL_ID);
bw.Write(Price);
bw.Write(ShowroomUnlock);
bw.Write(Tier1Price);
bw.Write(Tier2Price);
bw.Write(Tier3Price);
bw.Write(Tier4Price);
bw.Write(Tier);
bw.Write(Tier1ShowroomUnlock);
bw.Write(Tier2ShowroomUnlock);
bw.Write(Tier3ShowroomUnlock);
bw.Write(Tier4ShowroomUnlock);
bw.AlignWriter(4);
bw.Write(BrandHALId);
bw.Write(LogoTextureId);
bw.Write(DetailHash);
PartDetails.Write(vault, bw);
_offerIdText.Write(vault, bw);
bw.Write(IsOnlineLockable);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
var binPointers = vault.SaveContext.Pointers.Where(p => p.Type == VltPointerType.Bin).ToList();
var vltPointers = vault.SaveContext.Pointers.Where(p => p.Type == VltPointerType.Vlt).ToList();
{
var targetBin = ExportFactory.CreatePtrRef(vault);
targetBin.PtrType = EPtrRefType.PtrSetFixupTarget;
targetBin.Index = 1;
targetBin.Write(vault, bw);
foreach (var binPointer in binPointers)
{
var ptr = ExportFactory.CreatePtrRef(vault);
ptr.PtrType = binPointer.Destination == 0 ? EPtrRefType.PtrNull : EPtrRefType.PtrDepRelative;
ptr.FixupOffset = binPointer.FixUpOffset;
ptr.Destination = binPointer.Destination;
ptr.Index = 1;
ptr.Write(vault, bw);
}
}
{
var targetVlt = ExportFactory.CreatePtrRef(vault);
targetVlt.PtrType = EPtrRefType.PtrSetFixupTarget;
targetVlt.Index = 0;
targetVlt.Write(vault, bw);
foreach (var vltPointer in vltPointers)
{
var ptr = ExportFactory.CreatePtrRef(vault);
ptr.PtrType = vltPointer.Destination == 0 ? EPtrRefType.PtrNull : EPtrRefType.PtrDepRelative;
ptr.FixupOffset = vltPointer.FixUpOffset;
ptr.Destination = vltPointer.Destination;
ptr.Index = 1;
ptr.Write(vault, bw);
}
}
{
var end = ExportFactory.CreatePtrRef(vault);
end.PtrType = EPtrRefType.PtrEnd;
end.Write(vault, bw);
}
bw.AlignWriter(0x10);
}
public override void Write(Vault vault, BinaryWriter bw)
{
_ptrPackagesSrc = bw.BaseStream.Position;
bw.Write(0);
bw.Write(Cost);
bw.Write(Tier1_Cost);
bw.Write(Tier2_Cost);
bw.Write(Tier3_Cost);
bw.Write(Tier4_Cost);
_offerIdText = new Text(Class, Field, Collection)
{
Value = OfferID
};
_offerIdText.Write(vault, bw);
bw.Write((byte)Entries.Count);
bw.AlignWriter(4);
}
public override void Write(Vault vault, BinaryWriter bw)
{
Assembly currentAssembly = Assembly.GetAssembly(typeof(Database));
AssemblyMetadataAttribute metadataAttribute =
currentAssembly.GetCustomAttributes <AssemblyMetadataAttribute>().First(m => m.Key == "GitHash");
Strings.Insert(0, "Generated by VaultBoy by heyitsleo");
Strings.Insert(1, $"{metadataAttribute.Value} | {DateTime.Now:s}");
foreach (string s in Strings)
{
vault.SaveContext.StringOffsets[s] = bw.BaseStream.Position;
NullTerminatedString.Write(bw, s);
}
bw.AlignWriter(0x10);
}
public override void Write(Vault vault, BinaryWriter bw)
{
//bw.Write(_exports.Count);
if (vault.Database.Options.Type == DatabaseType.X64Database)
{
bw.Write((ulong)_exports.Count);
}
else
{
bw.Write(_exports.Count);
}
foreach (var exportEntry in _exports)
{
exportEntry.Write(vault, bw);
}
bw.AlignWriter(0x10);
}