/// <summary>
/// Exports the given asset from this pool
/// </summary>
public HydraStatus Export(GameAsset asset, HydraInstance instance)
{
var header = instance.Reader.ReadStruct <RumbleAsset>(asset.HeaderAddress);
if (asset.Name != instance.Reader.ReadNullTerminatedString(header.NamePointer))
{
return(HydraStatus.MemoryChanged);
}
var rumbleAsset = new GameDataTable.Asset(asset.Name, "rumble");
rumbleAsset["broadcast"] = header.Broadcast;
rumbleAsset["camShakeDuration"] = header.CamShakeDuration;
rumbleAsset["camShakeRange"] = header.CamShakeRange;
rumbleAsset["camShakeScale"] = header.CamShakeScale;
rumbleAsset["duration"] = header.Duration;
rumbleAsset["fadeWithDistance"] = header.FadeWithDistance;
rumbleAsset["pulseBoneTagPointer"] = instance.Game.GetString(header.PulseBoneTagStringIndex, instance);
rumbleAsset["pulseRadiusOuter"] = header.PulseRadiusOuter;
rumbleAsset["pulseScale"] = header.PulseScale;
rumbleAsset["range"] = header.Range;
rumbleAsset["lowrumblefile"] = WriteRumbleFile(header.LowRumbleFilePointer, instance);
rumbleAsset["highrumblefile"] = WriteRumbleFile(header.HighRumbleFilePointer, instance);
instance.GDTs["Physic"][rumbleAsset.Name] = rumbleAsset;
return(HydraStatus.Success);
}
/// <summary>
/// Exports the given asset from this pool
/// </summary>
public HydraStatus Export(GameAsset asset, HydraInstance instance)
{
var header = instance.Reader.ReadStruct <TagFXAsset>(asset.HeaderAddress);
if (asset.Name != instance.Reader.ReadNullTerminatedString(header.NamePointer))
{
return(HydraStatus.MemoryChanged);
}
var tagFXAsset = new GameDataTable.Asset(asset.Name, "tagfx");
tagFXAsset["tagFXItemCount"] = header.ItemCount;
var items = instance.Reader.ReadArray <TagFXItem>(header.ItemsPointer, header.ItemCount);
for (int i = 0; i < items.Length; i++)
{
tagFXAsset["bolted" + (i + 1).ToString()] = items[i].Bolted;
tagFXAsset["fx" + (i + 1).ToString()] = instance.Game.CleanAssetName(HydraAssetType.FX, instance.Game.GetAssetName(items[i].FXPointer, instance));
tagFXAsset["timeDelay" + (i + 1).ToString()] = items[i].Delay;
tagFXAsset["tag" + (i + 1).ToString()] = instance.Game.GetString(items[i].TagNameIndex, instance);
}
instance.GDTs["Misc"][asset.Name] = tagFXAsset;
return(HydraStatus.Success);
}
/// <summary>
/// Exports the given asset from this pool
/// </summary>
public HydraStatus Export(GameAsset asset, HydraInstance instance)
{
var header = instance.Reader.ReadStruct <AttachmentCosmeticVariantAsset>(asset.HeaderAddress);
if (asset.Name != instance.Reader.ReadNullTerminatedString(header.NamePointer))
{
return(HydraStatus.FailedToFindGame);
}
var result = new GameDataTable.Asset(asset.Name, "attachmentcosmeticvariant");
var variants = instance.Reader.ReadArray <Variant>(header.VariantsPointer, header.VariantCount);
for (int i = 0; i < variants.Length; i++)
{
for (int j = 0; j < variants[i].VariantModels.Length; j++)
{
result[string.Format("acv{0}_{1}_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = instance.Game.GetAssetName(variants[i].VariantModels[j].ModelPointer, instance);
result[string.Format("acv{0}_{1}ADS_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = instance.Game.GetAssetName(variants[i].VariantModels[j].ADSModelPointer, instance);
result[string.Format("acv{0}_{1}Tag_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = instance.Reader.ReadNullTerminatedString(variants[i].VariantModels[j].TagPointer);
result[string.Format("acv{0}_{1}OffsetX_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = variants[i].VariantModels[j].Position.X;
result[string.Format("acv{0}_{1}OffsetY_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = variants[i].VariantModels[j].Position.Y;
result[string.Format("acv{0}_{1}OffsetZ_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = variants[i].VariantModels[j].Position.Z;
result[string.Format("acv{0}_{1}OffsetPitch_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = variants[i].VariantModels[j].Rotation.X;
result[string.Format("acv{0}_{1}OffsetYaw_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = variants[i].VariantModels[j].Rotation.Y;
result[string.Format("acv{0}_{1}OffsetRoll_model{2}", i, ModelNames[j < 2 ? 0 : 1], j % 2)] = variants[i].VariantModels[j].Rotation.Z;
}
result[string.Format("acv{0}_description", i)] = instance.Reader.ReadNullTerminatedString(variants[i].DescriptionPointer);
result[string.Format("acv{0}_displayNameShort", i)] = instance.Reader.ReadNullTerminatedString(variants[i].ShortDisplayNamePointer);
result[string.Format("acv{0}_displayNameLong", i)] = instance.Reader.ReadNullTerminatedString(variants[i].LongDisplayNamePointer);
result[string.Format("acv{0}_uiMaterial", i)] = instance.Game.GetAssetName(variants[i].MaterialPointer, instance, 0xF8);
}
instance.GDTs["Weapon"][asset.Name] = result;
// Done
return(HydraStatus.Success);
}
/// <summary>
/// Exports the given asset from this pool
/// </summary>
public HydraStatus Export(GameAsset asset, HydraInstance instance)
{
var header = instance.Reader.ReadStruct <WeaponCamoAsset>(asset.HeaderAddress);
if (asset.Name != instance.Reader.ReadNullTerminatedString(header.NamePointer))
{
return(HydraStatus.MemoryChanged);
}
var weaponCamos = instance.Reader.ReadArray <WeaponCamoEntry>(header.CamosPointer, header.CamoCount);
var weaponCamoAssetNames = new string[10];
var weaponCamoAssetCount = (int)Math.Ceiling(weaponCamos.Length / 75.0);
for (int i = 0; i < weaponCamoAssetCount; i++)
{
int camoCount = MathUtilities.Clamp(weaponCamos.Length - (i * 75), 75, 0);
int baseIndex = i * 75;
weaponCamoAssetNames[i] = string.Format("{0}{1}", asset.Name, i == 0 ? "_ship" : "_base" + (baseIndex + 1).ToString());
var weaponCamoAsset = new GameDataTable.Asset(weaponCamoAssetNames[i], "weaponcamo");
weaponCamoAsset.Properties["configstringFileType"] = "WEAPONCAMO";
weaponCamoAsset.Properties["baseIndex"] = baseIndex + 1;
weaponCamoAsset.Properties["numCamos"] = camoCount;
for (int j = 0; j < camoCount; j++)
{
var weaponCamoMaterial = weaponCamos[baseIndex + j];
var materials = instance.Reader.ReadArray <WeaponCamoMaterial>(weaponCamoMaterial.MaterialsCount == 0 ? 0 : weaponCamoMaterial.MaterialsPointer, weaponCamoMaterial.MaterialsCount == 0 ? 1 : weaponCamoMaterial.MaterialsCount);
for (int k = 0; k < materials.Length; k++)
{
var weaponCamoBaseMaterials = instance.Reader.ReadArray <WeaponCamoBaseMaterial>(materials[k].BaseMaterialsPointer, materials[k].BaseMaterialCount);
for (int l = 0; l < weaponCamoBaseMaterials.Length; l++)
{
weaponCamoAsset[string.Format("material{0}_{1}_base_material_{2}", k + 1, j + 1, l + 1)] = Path.GetFileNameWithoutExtension(instance.Game.GetAssetName(weaponCamoBaseMaterials[l].MaterialPointer, instance));
weaponCamoAsset[string.Format("material{0}_{1}_camo_mask_{2}", k + 1, j + 1, l + 1)] = instance.Game.GetAssetName(weaponCamoBaseMaterials[l].CamoMaskPointer, instance, 0xF8);
}
weaponCamoAsset[string.Format("material{0}_{1}_detail_normal_height", k + 1, j + 1)] = materials[k].NormalHeight;
weaponCamoAsset[string.Format("material{0}_{1}_detail_normal_map", k + 1, j + 1)] = instance.Game.GetAssetName(materials[k].DetailNormalMapPointer, instance, 0xF8);
weaponCamoAsset[string.Format("material{0}_{1}_detail_normal_scale_x", k + 1, j + 1)] = materials[k].NormalScale.X;
weaponCamoAsset[string.Format("material{0}_{1}_detail_normal_scale_y", k + 1, j + 1)] = materials[k].NormalScale.Y;
weaponCamoAsset[string.Format("material{0}_{1}_gloss_blend", k + 1, j + 1)] = materials[k].GlossMapBlend;
weaponCamoAsset[string.Format("material{0}_{1}_normal_amount", k + 1, j + 1)] = materials[k].NormalBlend;
weaponCamoAsset[string.Format("material{0}_{1}_material", k + 1, j + 1)] = Path.GetFileNameWithoutExtension(instance.Game.GetAssetName(materials[k].MaterialPointer, instance));
weaponCamoAsset[string.Format("material{0}_{1}_numBaseMaterials", k + 1, j + 1)] = materials[k].BaseMaterialCount;
weaponCamoAsset[string.Format("material{0}_{1}_rotation", k + 1, j + 1)] = materials[k].Rotation;
weaponCamoAsset[string.Format("material{0}_{1}_scale_x", k + 1, j + 1)] = materials[k].Scale.X;
weaponCamoAsset[string.Format("material{0}_{1}_scale_y", k + 1, j + 1)] = materials[k].Scale.Y;
weaponCamoAsset[string.Format("material{0}_{1}_trans_x", k + 1, j + 1)] = materials[k].Translation.X;
weaponCamoAsset[string.Format("material{0}_{1}_trans_y", k + 1, j + 1)] = materials[k].Translation.Y;
weaponCamoAsset[string.Format("material{0}_{1}_useGlossMap", k + 1, j + 1)] = materials[k].Flags.HasFlag(MaterialUsageFlags.GlossMap);
weaponCamoAsset[string.Format("material{0}_{1}_useNormalMap", k + 1, j + 1)] = materials[k].Flags.HasFlag(MaterialUsageFlags.NormalMap);
}
}
instance.GDTs["Weapon"][weaponCamoAssetNames[i]] = weaponCamoAsset;
}
var weaponCamoTableAsset = new GameDataTable.Asset(asset.Name, "weaponcamotable");
weaponCamoTableAsset["configstringFileType"] = "WEAPONCAMO";
weaponCamoTableAsset["numCamoTables"] = weaponCamoAssetNames.Count(x => x != null);
for (int i = 0; i < weaponCamoAssetNames.Length; i++)
{
weaponCamoTableAsset[string.Format("table_{0:D2}_name", i + 1)] = weaponCamoAssetNames[i];
}
instance.GDTs["Weapon"][asset.Name] = weaponCamoTableAsset;
return(HydraStatus.Success);
}
/// <summary>
/// Exports the given asset from this pool
/// </summary>
public HydraStatus Export(GameAsset asset, HydraInstance instance)
{
var header = instance.Reader.ReadStruct <ZBarrierAsset>(asset.HeaderAddress);
if (asset.Name != instance.Reader.ReadNullTerminatedString(header.NamePointer))
{
return(HydraStatus.MemoryChanged);
}
var zbarrierAsset = new GameDataTable.Asset(asset.Name, "zbarrier");
zbarrierAsset["generalRepairSound0"] = GetAliasByHash(header.GeneralRepairSoundHash);
zbarrierAsset["generalRepairSound1"] = GetAliasByHash(header.SecondGeneralRepairSoundHash);
zbarrierAsset["upgradedGeneralRepairSound0"] = GetAliasByHash(header.UpgradedGeneralRepairSoundHash);
zbarrierAsset["upgradedGeneralRepairSound1"] = GetAliasByHash(header.SecondUpgradedGeneralRepairSoundHash);
zbarrierAsset["useDelayBetweenGeneralRepSounds"] = header.DelayBetweenSounds.ToString();
zbarrierAsset["delayBetweenGeneralRepSounds"] = header.Delay.ToString();
zbarrierAsset["earthquakeOnRepair"] = header.EarthquakeOnRepair.ToString();
zbarrierAsset["earthquakeMinScale"] = header.EarthquakeMinScale.ToString();
zbarrierAsset["earthquakeMaxScale"] = header.EarthquakeMaxScale.ToString();
zbarrierAsset["earthquakeMinDuration"] = header.EarthquakeMinDuration.ToString();
zbarrierAsset["earthquakeMaxDuration"] = header.EarthquakeMaxDuration.ToString();
zbarrierAsset["earthquakeRadius"] = header.EarthquakeRadius.ToString();
zbarrierAsset["autoHideOpenPieces"] = header.AutoHideOpenPieces.ToString();
zbarrierAsset["taunts"] = header.ZombiesTaunt.ToString();
zbarrierAsset["reachThroughAttacks"] = header.ZombiesReachThrough.ToString();
zbarrierAsset["zombieTauntAnimState"] = instance.Game.GetString(header.AnimStateStringIndex, instance);
zbarrierAsset["zombieReachThroughAnimState"] = instance.Game.GetString(header.AnimSubStateStringIndex, instance);
zbarrierAsset["numAttackSlots"] = header.AttackSlotCount.ToString();
zbarrierAsset["attackSpotHorzOffset"] = header.AttackHorizontalOffset.ToString();
zbarrierAsset["collisionModel"] = instance.Game.GetAssetName(header.CollisionModelPointer, instance);
for (int i = 0; i < header.PieceCount; i++)
{
// Add it to asset
zbarrierAsset[string.Format("boardModel{0}", i + 1)] = instance.Game.GetAssetName(header.Pieces[i].PieceModelPointer, instance);
zbarrierAsset[string.Format("upgradedBoardModel{0}", i + 1)] = instance.Game.GetAssetName(header.Pieces[i].UpgradedPieceModelPointer, instance);
zbarrierAsset[string.Format("alternateBoardModel{0}", i + 1)] = instance.Game.GetAssetName(header.Pieces[i].AlternatePieceModelPointer, instance);
zbarrierAsset[string.Format("boardAnim{0}", i + 1)] = instance.Reader.ReadNullTerminatedString(header.Pieces[i].ClosingAnimNamePointer);
zbarrierAsset[string.Format("tearAnim{0}", i + 1)] = instance.Reader.ReadNullTerminatedString(header.Pieces[i].OpeningAnimNamePointer);
zbarrierAsset[string.Format("boardRepairSound{0}", i + 1)] = GetAliasByHash(header.Pieces[i].BoardClosingSoundHash);
zbarrierAsset[string.Format("boardRepairHoverSound{0}", i + 1)] = GetAliasByHash(header.Pieces[i].BoardClosingHoverSoundHash);
zbarrierAsset[string.Format("repairFx{0}0", i + 1)] = instance.Game.CleanAssetName(HydraAssetType.FX, instance.Game.GetAssetName(header.Pieces[i].FirstClosingFXPointer, instance));
zbarrierAsset[string.Format("repairFx{0}1", i + 1)] = instance.Game.CleanAssetName(HydraAssetType.FX, instance.Game.GetAssetName(header.Pieces[i].SecondClosingFXPointer, instance));
zbarrierAsset[string.Format("OffsetRepairFxX{0}0", i + 1)] = header.Pieces[i].FirstClosingFXOffset.X.ToString();
zbarrierAsset[string.Format("OffsetRepairFxY{0}0", i + 1)] = header.Pieces[i].FirstClosingFXOffset.Y.ToString();
zbarrierAsset[string.Format("OffsetRepairFxZ{0}0", i + 1)] = header.Pieces[i].FirstClosingFXOffset.Z.ToString();
zbarrierAsset[string.Format("OffsetRepairFxX{0}1", i + 1)] = header.Pieces[i].SecondClosingFXOffset.X.ToString();
zbarrierAsset[string.Format("OffsetRepairFxY{0}1", i + 1)] = header.Pieces[i].SecondClosingFXOffset.Y.ToString();
zbarrierAsset[string.Format("OffsetRepairFxZ{0}1", i + 1)] = header.Pieces[i].SecondClosingFXOffset.Z.ToString();
zbarrierAsset[string.Format("zombieBoardTearAnimState{0}", i + 1)] = instance.Game.GetString(header.Pieces[i].AnimStateStringIndex, instance);
zbarrierAsset[string.Format("zombieBoardTearAnimSubState{0}", i + 1)] = instance.Game.GetString(header.Pieces[i].AnimSubStateStringIndex, instance);
zbarrierAsset[string.Format("pauseAndRepeatBoardRepairSound{0}", i + 1)] = header.Pieces[i].PauseAndRepeat.ToString();
zbarrierAsset[string.Format("pauseBetweenRepSoundsMin{0}", i + 1)] = header.Pieces[i].MinPause.ToString();
zbarrierAsset[string.Format("pauseBetweenRepSoundsMax{0}", i + 1)] = header.Pieces[i].MaxPause.ToString();
zbarrierAsset[string.Format("proBoardNumRepsToTear{0}", i + 1)] = header.Pieces[i].LoopAnimRepsCount.ToString();
}
instance.GDTs["Misc"][asset.Name] = zbarrierAsset;
return(HydraStatus.Success);
}
/// <summary>
/// Exports the given asset from this pool
/// </summary>
public HydraStatus Export(GameAsset asset, HydraInstance instance)
{
var header = instance.Reader.ReadStruct <XCamAsset>(asset.HeaderAddress);
if (asset.Name != instance.Reader.ReadNullTerminatedString(header.NamePointer))
{
return(HydraStatus.FailedToFindGame);
}
var path = Path.Combine(instance.ExportFolder, "xanim_export", "hydra_xcams", asset.Name + ".xcam_export");
var gdtAsset = new GameDataTable.Asset(asset.Name, "xcam");
gdtAsset["hide_hud"] = header.Flags[0];
gdtAsset["is_looping"] = header.Flags[1];
gdtAsset["hide_local_player"] = header.Flags[2];
gdtAsset["use_firstperson_player"] = header.Flags[3];
gdtAsset["disableNearDof"] = header.Flags[4];
gdtAsset["autoMotionBlur"] = header.Flags[5];
gdtAsset["easeAnimationsOut"] = header.Flags[6];
gdtAsset["rightStickRotateOffsetX"] = header.RightStickRotationOffset.X;
gdtAsset["rightStickRotateOffsetY"] = header.RightStickRotationOffset.Y;
gdtAsset["rightStickRotateOffsetZ"] = header.RightStickRotationOffset.Z;
gdtAsset["rightStickRotateMaxDegreesX"] = header.RightStickRotationDegrees.X;
gdtAsset["rightStickRotateMaxDegreesY"] = header.RightStickRotationDegrees.Y;
gdtAsset["parent_scene"] = instance.Reader.ReadNullTerminatedString(header.ParentScenePointer);
gdtAsset["filename"] = Path.Combine("hydra_xcams", asset.Name + ".xcam_export");
instance.GDTs["XCams"][gdtAsset.Name] = gdtAsset;
var xcam = new XCamObj
{
Cameras = new XCamObj.Camera[header.CameraCount],
Notetracks = new XCamObj.Notetrack[header.NotetrackCount],
CameraSwitches = new XCamObj.CameraSwitch[header.CameraSwitchPointer > 0 ? header.FrameCount : 0]
};
var cameras = instance.Reader.ReadArray <XCamCamera>(header.CamerasPointer, header.CameraCount);
for (int i = 0; i < cameras.Length; i++)
{
xcam.Cameras[i] = new XCamObj.Camera
{
Farz = cameras[i].FarZ,
Name = instance.Game.GetString(cameras[i].NameStringIndex, instance),
Animations = new XCamObj.CameraAnimation[cameras[i].AnimationCount]
};
var animations = instance.Reader.ReadArray <XCamCameraAnimation>(cameras[i].AnimationsPointer, cameras[i].AnimationCount);
for (int j = 0; j < animations.Length; j++)
{
xcam.Cameras[i].Animations[j] = new XCamObj.CameraAnimation();
Matrix matrix = new Quaternion()
{
X = animations[i].Rotation.X,
Y = animations[i].Rotation.Y,
Z = animations[i].Rotation.Z,
W = animations[i].Rotation.W,
}.ToMatrix();
xcam.Cameras[i].Animations[j].Dir[0] = matrix.X[0];
xcam.Cameras[i].Animations[j].Dir[1] = matrix.Y[0];
xcam.Cameras[i].Animations[j].Dir[2] = matrix.Z[0];
xcam.Cameras[i].Animations[j].Up[0] = matrix.X[2];
xcam.Cameras[i].Animations[j].Up[1] = matrix.Y[2];
xcam.Cameras[i].Animations[j].Up[2] = matrix.Z[2];
xcam.Cameras[i].Animations[j].Right[0] = matrix.X[1] * -1;
xcam.Cameras[i].Animations[j].Right[1] = matrix.Y[1] * -1;
xcam.Cameras[i].Animations[j].Right[2] = matrix.Z[1] * -1;
xcam.Cameras[i].Animations[j].Origin[0] = animations[i].Origin.X;
xcam.Cameras[i].Animations[j].Origin[1] = animations[i].Origin.Y;
xcam.Cameras[i].Animations[j].Origin[2] = animations[i].Origin.Z;
xcam.Cameras[i].Animations[j].FieldOfView = animations[i].FieldofView;
xcam.Cameras[i].Animations[j].FocalLength = animations[i].FocalLength;
xcam.Cameras[i].Animations[j].FDist = animations[i].FDist;
xcam.Cameras[i].Animations[j].FStop = animations[i].FStop;
xcam.Cameras[i].Animations[j].Frame = animations[i].Frame;
if (j == 0)
{
xcam.Cameras[i].Origin = xcam.Cameras[i].Animations[j].Origin;
xcam.Cameras[i].Dir = xcam.Cameras[i].Animations[j].Dir;
xcam.Cameras[i].Up = xcam.Cameras[i].Animations[j].Up;
xcam.Cameras[i].Right = xcam.Cameras[i].Animations[j].Right;
xcam.Cameras[i].FieldOfView = xcam.Cameras[i].Animations[j].FieldOfView;
xcam.Cameras[i].FocalLength = xcam.Cameras[i].Animations[j].FocalLength;
xcam.Cameras[i].FDist = xcam.Cameras[i].Animations[j].FDist;
xcam.Cameras[i].FStop = xcam.Cameras[i].Animations[j].FStop;
}
}
}
if (header.TargetModelRootBonePointer > 0)
{
var rootBone = instance.Reader.ReadStruct <XCamTargetModelRootBone>(header.TargetModelRootBonePointer);
xcam.TargetModelBoneRoots = new XCamObj.TargetModelBoneRoot[1]
{
new XCamObj.TargetModelBoneRoot()
{
Name = instance.Game.GetString(rootBone.NameStringIndex, instance),
Animation = new XCamObj.TargetModelBoneRootFrame[rootBone.AnimationCount]
}
};
var animations = instance.Reader.ReadArray <XCamTargetModelRootBoneAnimation>(rootBone.AnimationsPointer, rootBone.AnimationCount);
for (int i = 0; i < rootBone.AnimationCount; i++)
{
Matrix matrix = new Quaternion()
{
X = animations[i].Rotation.X,
Y = animations[i].Rotation.Y * -1,
Z = animations[i].Rotation.Z * -1,
W = animations[i].Rotation.W,
}.ToMatrix();
xcam.TargetModelBoneRoots[0].Animation[i] = new XCamObj.TargetModelBoneRootFrame();
xcam.TargetModelBoneRoots[0].Animation[i].Offset[0] = animations[i].Origin.X;
xcam.TargetModelBoneRoots[0].Animation[i].Offset[1] = animations[i].Origin.Y * -1;
xcam.TargetModelBoneRoots[0].Animation[i].Offset[2] = animations[i].Origin.Z;
xcam.TargetModelBoneRoots[0].Animation[i].Axis["x"] = matrix.X;
xcam.TargetModelBoneRoots[0].Animation[i].Axis["y"] = matrix.Y;
xcam.TargetModelBoneRoots[0].Animation[i].Axis["z"] = matrix.Z;
xcam.TargetModelBoneRoots[0].Animation[i].Frame = i;
}
}
var notetracks = instance.Reader.ReadArray <XCamNotetrack>(header.NotetracksPointer, header.NotetrackCount);
for (int i = 0; i < notetracks.Length; i++)
{
xcam.Notetracks[i] = new XCamObj.Notetrack(instance.Game.GetString(notetracks[i].NameStringIndex, instance), notetracks[i].Frame);
}
if (header.CameraSwitchPointer > 0)
{
var switches = instance.Reader.ReadArray <XCamSwitch>(header.CameraSwitchPointer, header.FrameCount);
for (int i = 0; i < switches.Length; i++)
{
xcam.CameraSwitches[i] = new XCamObj.CameraSwitch()
{
Cameras = new int[2] {
switches[i].Camera1Index, switches[i].Camera2Index
},
Dissolve = switches[i].Dissolve,
Frame = switches[i].Frame
};
}
}
xcam.Save(path);
// Done
return(HydraStatus.Success);
}
public static Asset ConvertStructToGDTAsset(byte[] assetBuffer, Tuple <string, int, int>[] properties, HydraInstance instance, Func <byte[], int, int, HydraInstance, object> extendedDataHandler = null)
{
// Create new asset
var asset = new GameDataTable.Asset();
// Loop through potential properties
foreach (var property in properties)
{
// Switch type
switch (property.Item3)
{
// Strings (Enum that points to a string)
case 0:
{
asset[property.Item1] = instance.Reader.ReadNullTerminatedString(BitConverter.ToInt64(assetBuffer, property.Item2));
break;
}
// Inline Character Array?
case 1:
{
asset[property.Item1] = Encoding.ASCII.GetString(assetBuffer, property.Item2, 1024).TrimEnd('\0');
break;
}
// Inline Character Array?
case 2:
{
asset[property.Item1] = Encoding.ASCII.GetString(assetBuffer, property.Item2, 64).TrimEnd('\0');
break;
}
// Inline Character Array?
case 3:
{
asset[property.Item1] = Encoding.ASCII.GetString(assetBuffer, property.Item2, 256).TrimEnd('\0');
break;
}
// 32Bit Ints
case 4:
{
asset[property.Item1] = BitConverter.ToInt32(assetBuffer, property.Item2);
break;
}
/// Unknown
case 5:
{
asset[property.Item1] = BitConverter.ToInt32(assetBuffer, property.Item2);
break;
}
// Bools (8Bit)
case 6:
{
asset[property.Item1] = assetBuffer[property.Item2];
break;
}
// Bools (32bit)
case 7:
{
asset[property.Item1] = BitConverter.ToInt32(assetBuffer, property.Item2);
break;
}
// Floats
case 8:
{
asset[property.Item1] = BitConverter.ToSingle(assetBuffer, property.Item2);
break;
}
// Floats that get multiplied by 1000
case 9:
{
asset[property.Item1] = BitConverter.ToInt32(assetBuffer, property.Item2) / 1000.0;
break;
}
// Script Strings
case 0x15:
{
asset[property.Item1] = instance.Game.GetString(BitConverter.ToInt32(assetBuffer, property.Item2), instance);
break;
}
// Asset References
case 0x28:
{
// Pull from the weapon name rather than the asset name
asset[property.Item1] = instance.Game.GetAssetName(BitConverter.ToInt64(assetBuffer, property.Item2), instance, 8);
break;
}
case 0xA:
case 0xB:
case 0xD:
case 0x10:
case 0x1F:
case 0x1B:
case 0x1D:
case 0x19:
case 0x1A:
case 0x26:
case 0x27:
case 0x2A:
case 0x2C:
case 0x2D:
case 0x11:
case 0x16:
case 0x17:
case 0x1E:
case 0x2F:
case 0x22:
case 0x23:
case 0x20:
{
var assetName = instance.Game.GetAssetName(BitConverter.ToInt64(assetBuffer, property.Item2), instance, property.Item3 == 0x10 ? 0xF8 : 0);
if (property.Item3 == 0xA)
{
assetName = instance.Game.CleanAssetName(HydraAssetType.FX, assetName);
}
asset[property.Item1] = assetName;
break;
}
case 0x2B:
case 0x2E:
{
var assetName = instance.Game.GetAssetName(BitConverter.ToInt64(assetBuffer, property.Item2), instance, 0x1B0);
asset[property.Item1] = assetName;
break;
}
case 0x18:
{
asset[property.Item1] = BlackOps3.GetAliasByHash(BitConverter.ToUInt32(assetBuffer, property.Item2));
break;
}
default:
{
// Attempt to use the extended data handler, otherwise null
var result = extendedDataHandler?.Invoke(assetBuffer, property.Item2, property.Item3, instance);
if (result != null)
{
asset[property.Item1] = result;
}
else
{
asset[property.Item1] = "";
#if DEBUG
Console.WriteLine("Unknown Value: {0} - {1} - {2}", property.Item3, property.Item2, property.Item1);
#endif
}
// Done
break;
}
}
}
// Done
return(asset);
}
/// <summary>
/// Exports the given asset from this pool
/// </summary>
public HydraStatus Export(GameAsset asset, HydraInstance instance)
{
var header = instance.Reader.ReadStruct <CustomizationTableAsset>(asset.HeaderAddress);
if (asset.Name != instance.Reader.ReadNullTerminatedString(header.NamePointer))
{
return(HydraStatus.MemoryChanged);
}
var customizationTable = new GameDataTable.Asset(asset.Name, "charactercustomizationtable");
customizationTable["bodyTypeCount"] = header.BodyCount;
customizationTable["headCount"] = header.HeadCount;
var playerHeads = instance.Reader.ReadArray <PlayerHeadAsset>(header.HeadsPointer, header.HeadCount);
for (int i = 0; i < playerHeads.Length; i++)
{
string name = instance.Reader.ReadNullTerminatedString(playerHeads[i].NamePointer);
var playerHead = new GameDataTable.Asset(name, "playerhead");
playerHead["displayName"] = instance.Reader.ReadNullTerminatedString(playerHeads[i].DisplayNamePointer);
playerHead["iconImage"] = instance.Game.GetAssetName(playerHeads[i].IconPointer, instance, 0xF8);
playerHead["model"] = instance.Game.GetAssetName(playerHeads[i].ModelPointer, instance);
playerHead["gender"] = (int)playerHeads[i].Gender;
customizationTable["head" + (i + 1).ToString("00")] = playerHead.Name;
instance.GDTs["Character"][playerHead.Name] = playerHead;
}
var playerBodyTypes = instance.Reader.ReadArray <PlayerBodyTypeAsset>(header.BodiesPointer, header.BodyCount);
for (int i = 0; i < playerBodyTypes.Length; i++)
{
var playerBodyType = new GameDataTable.Asset(instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].NamePointer), "playerbodytype");
playerBodyType["abilityCardBackDesc"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].AbilityCardBackDescPointer);
playerBodyType["abilityCardBackIcon"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].AbilityCardBackIconPointer);
playerBodyType["abilityCardBackSubIcon"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].AbilityCardBackSubIconPointer);
playerBodyType["abilityIconEquipped"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].AbilityIconEquippedPointer);
playerBodyType["abilityIconUnequipped"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].AbilityIconUnequippedPointer);
playerBodyType["abilitySchema"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].AbilitySchemaPointer);
playerBodyType["abilitySubItemDesc"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].AbilitySubItemDescPointer);
playerBodyType["age"] = playerBodyTypes[i].Age;
playerBodyType["background"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].BackgroundPointer);
playerBodyType["backgroundWithCharacter"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].BackgroundWithCharacterPointer);
playerBodyType["bio"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].BioPointer);
playerBodyType["bodySoundContext"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].BodySoundContextPointer);
playerBodyType["bodyStyleCount"] = playerBodyTypes[i].BodyStyleCount;
playerBodyType["cardBackIcon"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].CardBackIconPointer);
playerBodyType["characterFootstepsNPCLoud"] = instance.Game.GetAssetName(playerBodyTypes[i].CharacterFootstepsNPCLoudPointer, instance);
playerBodyType["characterFootstepsNPC"] = instance.Game.GetAssetName(playerBodyTypes[i].CharacterFootstepsNPCPointer, instance);
playerBodyType["characterFootstepsNPCQuiet"] = instance.Game.GetAssetName(playerBodyTypes[i].CharacterFootstepsNPCQuietPointer, instance);
playerBodyType["characterFootsteps"] = instance.Game.GetAssetName(playerBodyTypes[i].CharacterFootstepsPointer, instance);
playerBodyType["characterFootstepsQuiet"] = instance.Game.GetAssetName(playerBodyTypes[i].CharacterFootstepsQuietPointer, instance);
playerBodyType["characterMovementFx"] = instance.Game.GetAssetName(playerBodyTypes[i].CharacterMovementFxPointer, instance);
playerBodyType["characterMovementSounds"] = instance.Game.GetAssetName(playerBodyTypes[i].CharacterMovementSoundsPointer, instance);
playerBodyType["defaultHeroRenderAbility"] = instance.Game.GetAssetName(playerBodyTypes[i].DefaultHeroRenderAbilityPointer, instance, 0xF8);
playerBodyType["defaultHeroRender"] = instance.Game.GetAssetName(playerBodyTypes[i].DefaultHeroRenderPointer, instance, 0xF8);
playerBodyType["description"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].DescriptionPointer);
playerBodyType["disabled"] = playerBodyTypes[i].Disabled;
playerBodyType["displayName"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].DisplayNamePointer);
playerBodyType["dogTagEnemy"] = instance.Game.GetAssetName(playerBodyTypes[i].DogTagEnemyPointer, instance);
playerBodyType["dogtagFriendly"] = instance.Game.GetAssetName(playerBodyTypes[i].DogtagFriendlyPointer, instance);
playerBodyType["frontendVignetteStruct"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].FrontendVignetteStructPointer);
playerBodyType["frontendVignetteWeaponModel"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].FrontendVignetteWeaponModelPointer);
playerBodyType["frontendVignetteXAnim"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].FrontendVignetteXAnimPointer);
playerBodyType["frontendVignetteXCam"] = instance.Game.GetAssetName(playerBodyTypes[i].FrontendVignetteXCamPointer, instance);
playerBodyType["frozenMomentOverlay"] = instance.Game.GetAssetName(playerBodyTypes[i].FrozenMomentOverlayPointer, instance);
playerBodyType["frozenMomentRender"] = instance.Game.GetAssetName(playerBodyTypes[i].FrozenMomentRenderPointer, instance);
playerBodyType["gender"] = (int)playerBodyTypes[i].Gender;
playerBodyType["genderString"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].GenderStringPointer);
playerBodyType["helmetStyleCount"] = playerBodyTypes[i].HelmetStyleCount;
playerBodyType["heroAbility"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].HeroAbilityPointer);
playerBodyType["heroWeapon"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].HeroWeaponPointer);
playerBodyType["lockedImage"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].LockedImagePointer);
playerBodyType["mpDialog"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].MpDialogPointer);
playerBodyType["personalizeRender"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].PersonalizeRenderPointer);
playerBodyType["realName"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].RealNamePointer);
playerBodyType["rewardIcon"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].RewardIconPointer);
playerBodyType["weaponCardBackDesc"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].WeaponCardBackDescPointer);
playerBodyType["weaponCardBackIcon"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].WeaponCardBackIconPointer);
playerBodyType["weaponCardBackSubIcon"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].WeaponCardBackSubIconPointer);
playerBodyType["weaponIconEquipped"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].WeaponIconEquippedPointer);
playerBodyType["weaponIconUnequipped"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].WeaponIconUnequippedPointer);
playerBodyType["weaponSchema"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].WeaponSchemaPointer);
playerBodyType["weaponSubItemDesc"] = instance.Reader.ReadNullTerminatedString(playerBodyTypes[i].WeaponSubItemDescPointer);
playerBodyType["zombiePlayerIcon"] = instance.Game.GetAssetName(playerBodyTypes[i].ZombiePlayerIconPointer, instance, 0xF8);
var playerBodyStyles = instance.Reader.ReadArray <PlayerBodyStyleAsset>(playerBodyTypes[i].BodyStylesPointer, playerBodyTypes[i].BodyStyleCount);
for (int j = 0; j < playerBodyStyles.Length; j++)
{
var playerBodyStyle = new GameDataTable.Asset(instance.Reader.ReadNullTerminatedString(playerBodyStyles[j].NamePointer), "playerbodystyle");
playerBodyStyle["accentColorCount"] = playerBodyStyles[j].AccentColorCount;
playerBodyStyle["characterMovementFxOverride"] = instance.Game.GetAssetName(playerBodyStyles[j].CharacterMovementFxOverridePointer, instance);
playerBodyStyle["displayName"] = instance.Reader.ReadNullTerminatedString(playerBodyStyles[j].DisplayNamePointer);
playerBodyStyle["firstPersonCinematicModel"] = instance.Game.GetAssetName(playerBodyStyles[j].FirstPersonCinematicModelPointer, instance);
playerBodyStyle["firstPersonLegsModel"] = instance.Game.GetAssetName(playerBodyStyles[j].FirstPersonLegsModelPointer, instance);
playerBodyStyle["gibDef"] = instance.Game.GetAssetName(playerBodyStyles[j].GibDefPointer, instance);
playerBodyStyle["gibLegsBoth"] = instance.Game.GetAssetName(playerBodyStyles[j].GibLegsBothPointer, instance);
playerBodyStyle["gibLegsClean"] = instance.Game.GetAssetName(playerBodyStyles[j].GibLegsCleanPointer, instance);
playerBodyStyle["gibLegsLeft"] = instance.Game.GetAssetName(playerBodyStyles[j].GibLegsLeftPointer, instance);
playerBodyStyle["gibLegsRight"] = instance.Game.GetAssetName(playerBodyStyles[j].GibLegsRightPointer, instance);
playerBodyStyle["gibTorsoClean"] = instance.Game.GetAssetName(playerBodyStyles[j].GibTorsoCleanPointer, instance);
playerBodyStyle["gibTorsoLeft"] = instance.Game.GetAssetName(playerBodyStyles[j].GibTorsoLeftPointer, instance);
playerBodyStyle["gibTorsoRight"] = instance.Game.GetAssetName(playerBodyStyles[j].GibTorsoRightPointer, instance);
playerBodyStyle["iconImage"] = instance.Game.GetAssetName(playerBodyStyles[j].IconImagePointer, instance, 0xF8);
playerBodyStyle["impactTypeCorpse"] = ImpactTypes[playerBodyStyles[j].ImpactTypeCorpse];
playerBodyStyle["impactType"] = ImpactTypes[playerBodyStyles[j].ImpactType];
playerBodyStyle["viewArmsModel"] = instance.Game.GetAssetName(playerBodyStyles[j].ViewArmsModelPointer, instance);
playerBodyStyle["xmodel"] = instance.Game.GetAssetName(playerBodyStyles[j].XmodelPointer, instance);
var accents = instance.Reader.ReadArray <PlayerAccent>(playerBodyStyles[j].AccentsPointer, playerBodyStyles[j].AccentColorCount);
for (int k = 0; k < accents.Length; k++)
{
var accentOptions = instance.Reader.ReadArray <long>(accents[k].DataPointer, accents[k].DataCount);
playerBodyStyle[string.Format("accentColor{0}OptionsCount", k + 1)] = accents[k].DataCount;
for (int l = 0; l < accentOptions.Length; l++)
{
playerBodyStyle[string.Format("color_{0}_{1}", k + 1, l + 1)] = instance.Game.GetAssetName(accentOptions[l], instance);
}
}
playerBodyType["bodyStyle" + (j + 1).ToString("00")] = playerBodyStyle.Name;
instance.GDTs["Character"][playerBodyStyle.Name] = playerBodyStyle;
}
var playerHelmetStyles = instance.Reader.ReadArray <PlayerBodyStyleAsset>(playerBodyTypes[i].HelmetStylesPointer, playerBodyTypes[i].HelmetStyleCount);
for (int j = 0; j < playerHelmetStyles.Length; j++)
{
var playerHelmetStyle = new GameDataTable.Asset(instance.Reader.ReadNullTerminatedString(playerHelmetStyles[j].NamePointer), "playerhelmetstyle");
playerHelmetStyle["accentColorCount"] = playerHelmetStyles[j].AccentColorCount;
playerHelmetStyle["displayName"] = instance.Reader.ReadNullTerminatedString(playerHelmetStyles[j].DisplayNamePointer);
playerHelmetStyle["iconImage"] = instance.Game.GetAssetName(playerHelmetStyles[j].IconImagePointer, instance, 0xF8);
playerHelmetStyle["impactTypeCorpse"] = ImpactTypes[playerHelmetStyles[j].ImpactTypeCorpse];
playerHelmetStyle["impactType"] = ImpactTypes[playerHelmetStyles[j].ImpactType];
playerHelmetStyle["xmodel"] = instance.Game.GetAssetName(playerHelmetStyles[j].XmodelPointer, instance);
var accents = instance.Reader.ReadArray <PlayerAccent>(playerHelmetStyles[j].AccentsPointer, playerHelmetStyles[j].AccentColorCount);
for (int k = 0; k < accents.Length; k++)
{
var accentOptions = instance.Reader.ReadArray <long>(accents[k].DataPointer, accents[k].DataCount);
playerHelmetStyle[string.Format("accentColor{0}OptionsCount", k + 1)] = accents[k].DataCount;
for (int l = 0; l < accentOptions.Length; l++)
{
playerHelmetStyle[string.Format("color_{0}_{1}", k + 1, l + 1)] = instance.Game.GetAssetName(accentOptions[l], instance);
}
}
playerBodyType["helmetStyle" + (j + 1).ToString("00")] = playerHelmetStyle.Name;
instance.GDTs["Character"][playerHelmetStyle.Name] = playerHelmetStyle;
}
var dataBlocks = instance.Reader.ReadArray <KVPBlock>(playerBodyTypes[i].DataBlocksPointer, playerBodyTypes[i].DataBlockCount);
for (int j = 0; j < dataBlocks.Length; j++)
{
// Determine type if we're int, since bool and int share same, but the pointer value will be different? (only 2 are bool anyway but just in case)
var dataType = dataBlocks[i].DataType;
if (dataType == DataTypes.Int && (dataBlocks[i].DataPointer & 0xFFFFFFFF) != dataBlocks[i].Data)
{
dataType = DataTypes.Bool;
}
string propertyName = string.Format("{0}_{1}", dataType.ToString().ToLower(), instance.Game.GetString(dataBlocks[i].DataNameStringIndex, instance));
playerBodyType[propertyName] = dataBlocks[i].DataType == DataTypes.Int ? dataBlocks[i].Data.ToString() : instance.Game.GetString(dataBlocks[i].DataStringIndex, instance);
}
customizationTable["bodyType" + (i + 1).ToString("00")] = playerBodyType.Name;
instance.GDTs["Character"][playerBodyType.Name] = playerBodyType;
}
instance.GDTs["Character"][customizationTable.Name] = customizationTable;
return(HydraStatus.Success);
}
/// <summary>
/// Exports the given asset from this pool
/// </summary>
public HydraStatus Export(GameAsset asset, HydraInstance instance)
{
var header = instance.Reader.ReadStruct <MaterialAsset>(asset.HeaderAddress);
if (asset.Name != Path.GetFileNameWithoutExtension(instance.Reader.ReadNullTerminatedString(header.NamePointer).Split('|')[0]))
{
return(HydraStatus.MemoryChanged);
}
// We need the techset for buffer info
var techset = instance.Reader.ReadStruct <MaterialTechniqueSet>(header.TechniquePointer);
var mtlType = Path.GetFileNameWithoutExtension(instance.Reader.ReadNullTerminatedString(instance.Reader.ReadInt64(header.TechniquePointer)).Split('#')[0]);
if (!instance.TechniqueSetCache.TryGetValue(mtlType, out var set))
{
throw new ArgumentException("Unknown material type.", mtlType);
}
// Add base stuffs
// Create asset
var gdtAsset = new GameDataTable.Asset(asset.Name, "material");
// Set Default Properties
gdtAsset.Properties.Add("surfaceType", SurfaceTypes.TryGetValue(BitConverter.ToUInt32(header.FlagsAndSettings, 28), out var surfaceType) ? surfaceType : "<none>");
gdtAsset.Properties.Add("template", "material.template");
gdtAsset.Properties.Add("materialCategory", set.Category);
gdtAsset.Properties.Add("materialType", mtlType);
gdtAsset.Properties.Add("textureAtlasRowCount", header.FlagsAndSettings[6].ToString());
gdtAsset.Properties.Add("textureAtlasColumnCount", header.FlagsAndSettings[7].ToString());
gdtAsset.Properties.Add("usage", "<not in editor>");
for (int i = 0; i < header.SettingsPointers.Length; i++)
{
if (header.SettingsPointers[i].SettingsPointer == 0)
{
continue;
}
var technique = instance.Reader.ReadStruct <MaterialTechnique>(techset.TechniquePointers[i]);
var pass = instance.Reader.ReadStruct <MaterialTechniquePass>(technique.PassPointer);
var settings = ParseDXBC(instance.Reader.ReadBytes(pass.ShaderPointer, pass.ShaderSize));
if (settings == null)
{
throw new ArgumentException("Failed to find $Globals in DirectX Byte Code RDEF part", "settings");
}
var settingsInfo = instance.Reader.ReadStruct <MaterialSettingBuffer>(header.SettingsPointers[i].SettingsPointer);
var settingsBuffer = instance.Reader.ReadBytes(settingsInfo.BufferPointer, (int)settingsInfo.Size);
foreach (var setting in settings)
{
if (set.Settings.TryGetValue(setting.Key, out var gdtInfo))
{
switch (gdtInfo.DataType)
{
case SettingDataType.Boolean:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = (int)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.UInt1:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.UInt2:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[1]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 04), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.UInt3:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[1]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 04), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[2]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 08), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.UInt4:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[1]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 04), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[2]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 08), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[3]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = (uint)PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 12), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.Float1:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.Float2:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[1]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 04), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.Float3:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[1]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 04), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[2]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 08), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.Float4:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
gdtAsset[gdtInfo.GDTSlotNames[0]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[1]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 04), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[2]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 08), gdtInfo.PostProcessor);
}
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[3]))
{
gdtAsset[gdtInfo.GDTSlotNames[1]] = PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 12), gdtInfo.PostProcessor);
}
break;
}
case SettingDataType.Color:
{
if (!gdtAsset.Properties.ContainsKey(gdtInfo.GDTSlotNames[0]))
{
var r = MathUtilities.Clamp(PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 00), gdtInfo.PostProcessor), 1.0, 0.0);
var g = MathUtilities.Clamp(PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 04), gdtInfo.PostProcessor), 1.0, 0.0);
var b = MathUtilities.Clamp(PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 08), gdtInfo.PostProcessor), 1.0, 0.0);
var a = MathUtilities.Clamp(PerformPostProcess(BitConverter.ToSingle(settingsBuffer, setting.Value + 12), gdtInfo.PostProcessor), 1.0, 0.0);
gdtAsset[gdtInfo.GDTSlotNames[0]] = string.Format("{0:0.000000} {1:0.000000} {2:0.000000} {3:0.000000}", r, g, b, a);
}
break;
}
}
}
}
}
for (int j = 0; j < header.Counts[0]; j++)
{
var materialImage = instance.Reader.ReadStruct <MaterialImage>(header.ImageTablePointer + (j * 0x20));
if (set.ImageSlots.TryGetValue(materialImage.SemanticHash, out string slot))
{
gdtAsset.Properties[slot] = instance.Reader.ReadNullTerminatedString(instance.Reader.ReadInt64(materialImage.ImagePointer + 0xF8));
}
}
instance.GDTs["Misc"][asset.Name] = gdtAsset;
return(HydraStatus.Success);
}
