public override void ParseObject(AssetsReader reader)
{
IsEnabled = reader.ReadBoolean();
CastShadows = reader.ReadByte();
ReceiveShadows = reader.ReadByte();
DynamicOcclude = reader.ReadByte();
MotionVectors = reader.ReadByte();
LightProbeUsage = reader.ReadByte();
ReflectionProbeUsage = reader.ReadByte();
reader.AlignTo(4);
RenderingLayerMask = reader.ReadUInt32();
if (ObjectInfo.ParentFile.Metadata.VersionGte("2018.3"))
{
RendererPriority = reader.ReadInt32();
}
LightmapIndex = reader.ReadUInt16();
LightmapIndexDynamic = reader.ReadUInt16();
LightmapTilingOffset = new Vector4F(reader);
LightmapTilingOffsetDynamic = new Vector4F(reader);
Materials = reader.ReadArrayOf(r => (ISmartPtr <MaterialObject>)SmartPtr <MaterialObject> .Read(ObjectInfo.ParentFile, this, r));
StaticBatchInfo = new StaticBatchInfo(reader);
StaticBatchRoot = SmartPtr <Transform> .Read(ObjectInfo.ParentFile, this, reader);
ProbeAnchor = SmartPtr <Transform> .Read(ObjectInfo.ParentFile, this, reader);
LightProbeVolumeOverride = SmartPtr <GameObject> .Read(ObjectInfo.ParentFile, this, reader);
SortingLayerID = reader.ReadInt32();
SortingLayer = reader.ReadInt16();
SortingOrder = reader.ReadInt16();
}
public override void ParseObject(AssetsReader reader)
{
base.ParseObject(reader);
action = reader.ReadEnum <ActorAction>();
triggerHash = reader.ReadInt32();
motionData = SmartPtr <AssetsObject> .Read(ObjectInfo.ParentFile, this, reader);
}
public override void ParseObject(AssetsReader reader)
{
point = new WorldPoint(reader);
prefab = SmartPtr <GameObject> .Read(ObjectInfo.ParentFile, this, reader);
scale = new Vector3F(reader);
}
public static SmartPtr GetSystemHandleInformation()
{
int length = 0x10000;
while (true)
{
using (SmartPtr ptr = new SmartPtr())
{
ptr.Allocate(length);
int returnLength;
NtStatus ret = NativeMethods.NtQuerySystemInformation(
SystemInformationClass.
SystemHandleInformation,
ptr.Pointer, length, out returnLength
);
if (ret == NtStatus.InfoLengthMismatch)
{
length *= 2;
if (length > 1024 * 1024 * 1024)
{
throw new OutOfMemoryException("NtQuerySystemInformation fails");
}
}
else if (ret == NtStatus.Success)
{
return(ptr.Clone());
}
}
}
}
public void Benchmark_ReadWrite()
{
Int64 size = 100 * 1000000;
using (SmartPtr p = UnmanagedMemory.AllocHGlobalExSmartPtr(size))
{
string fileName = Path.GetTempFileName();
if (File.Exists(fileName))
{
File.Delete(fileName);
}
DateTime start = DateTime.Now;
using (BinaryWriter w = new BinaryWriter(File.Open(fileName, FileMode.CreateNew, FileAccess.Write)))
{
UnmanagedMemory.Write(w, p, size);
}
double time = (DateTime.Now - start).TotalSeconds;
Console.WriteLine("{0:#,#} bytes written to disk in {1:0.00000} s, {2:#,#} b/s", size, time, size / time);
start = DateTime.Now;
using (BinaryReader r = new BinaryReader(File.Open(fileName, FileMode.Open, FileAccess.Read)))
{
UnmanagedMemory.Read(r, p, size);
}
time = (DateTime.Now - start).TotalSeconds;
Console.WriteLine("{0:#,#} bytes read from disk in {1:0.00000} s, {2:#,#} b/s", size, time, size / time);
File.Delete(fileName);
}
}
private static string GetHandleTypeToken(IntPtr handle)
{
int length;
NativeMethods.NtQueryObject(
handle, ObjectInformationClass.ObjectTypeInformation, IntPtr.Zero, 0,
out length
);
using (SmartPtr sptr = new SmartPtr())
{
sptr.Allocate(length);
if (NativeMethods.NtQueryObject(
handle, ObjectInformationClass.ObjectTypeInformation,
sptr.Pointer, length, out length
) == NtStatus.Success
)
{
ObjectTypeInformation oti =
(ObjectTypeInformation)Marshal.PtrToStructure(sptr.Pointer, typeof(ObjectTypeInformation));
UnicodeString unicodeType = oti.Name;
string typeName = unicodeType.GetValue();
return(typeName);
}
}
return(string.Empty);
}
public void Test_Convert()
{
SmartPtr ptr = UnmanagedMemory.AllocHGlobalExSmartPtr(1);
UInt32 * pUInt32 = (UInt32 *)ptr;
Assert.IsTrue((UInt32 *)ptr.Ptr.ToPointer() == pUInt32);
}
public void Parse(AssetsFile file, AssetsObject owner, AssetsReader reader)
{
Texture = SmartPtr <Texture2DObject> .Read(file, owner, reader);
Scale = new Vector2F(reader);
Offset = new Vector2F(reader);
}
protected override void Parse(AssetsReader reader)
{
//new PPtr(x)
//to SmartPtr<BeatmapLevelPackObject>.Read(ObjectInfo.ParentFile,x)
base.Parse(reader);
BeatmapLevelPacks = reader.ReadArrayOf(x => SmartPtr <BeatmapLevelPackObject> .Read(ObjectInfo.ParentFile, this, x)).Cast <ISmartPtr <BeatmapLevelPackObject> >().ToList();
PreviewBeatmapLevelPacks = reader.ReadArrayOf(x => SmartPtr <MonoBehaviourObject> .Read(ObjectInfo.ParentFile, this, x)).Cast <ISmartPtr <MonoBehaviourObject> >().ToList();
}
public override void ParseObject(AssetsReader reader)
{
Material = SmartPtr <PhysicMaterial> .Read(ObjectInfo.ParentFile, this, reader);
IsTrigger = reader.ReadBoolean();
Enabled = reader.ReadBoolean();
reader.AlignTo(4);
}
private void Allocate(long nodesCount, int nodeByteSize)
{
_nodesCount = nodesCount;
_nodesByteSize = nodesCount * nodeByteSize;
_depthPtr = UnmanagedMemory.AllocHGlobalExSmartPtr(NodesCount);
_depths = (byte *)_depthPtr;
_nodesPtr = UnmanagedMemory.AllocHGlobalExSmartPtr(_nodesByteSize);
}
public override void ParseObject(AssetsReader reader)
{
autoRegister = reader.ReadBoolean();
reader.AlignTo(4);
hasHitPlayer = reader.ReadBoolean();
reader.AlignTo(4);
colliders = reader.ReadArrayOf(r => SmartPtr <Collider> .Read(ObjectInfo.ParentFile, this, r));
}
public override void ParseObject(AssetsReader reader)
{
LocalRotation = new QuaternionF(reader);
LocalPosition = new Vector3F(reader);
LocalScale = new Vector3F(reader);
Children = reader.ReadArrayOf(x => (SmartPtr <Transform>)SmartPtr <Transform> .Read(ObjectInfo.ParentFile, this, reader));
Father = SmartPtr <Transform> .Read(ObjectInfo.ParentFile, this, reader);
}
public override void ParseObject(AssetsReader reader)
{
base.ParseObject(reader);
decorations = SmartPtr <DecorationSet> .Read(ObjectInfo.ParentFile, this, reader);
decorationChance = reader.ReadSingle();
decorationDensity = reader.ReadSingle();
}
private void Parse(AssetsFile assetsFile, AssetsObject owner, AssetsReader reader)
{
Difficulty = (Difficulty)reader.ReadInt32();
DifficultyRank = reader.ReadInt32();
NoteJumpMovementSpeed = reader.ReadSingle();
NoteJumpStartBeatOffset = reader.ReadInt32();
BeatmapDataPtr = SmartPtr <BeatmapDataObject> .Read(assetsFile, owner, reader);
}
protected override void Parse(AssetsReader reader)
{
base.Parse(reader);
PlayerModel = SmartPtr <MonoBehaviourObject> .Read(ObjectInfo.ParentFile, this, reader);
ColorA = SmartPtr <MonoBehaviourObject> .Read(ObjectInfo.ParentFile, this, reader);
ColorB = SmartPtr <MonoBehaviourObject> .Read(ObjectInfo.ParentFile, this, reader);
}
public override void Parse(AssetsReader reader)
{
base.ParseBase(reader);
PlayerModel = SmartPtr <AssetsObject> .Read(ObjectInfo.ParentFile, this, reader);
ColorA = SmartPtr <SimpleColorSO> .Read(ObjectInfo.ParentFile, this, reader);
ColorB = SmartPtr <SimpleColorSO> .Read(ObjectInfo.ParentFile, this, reader);
}
public override void ParseObject(AssetsReader reader)
{
useAsDefault = reader.ReadBoolean();
reader.AlignTo(4);
frontLotKoreoSet = SmartPtr <WwiseKoreographySet> .Read(ObjectInfo.ParentFile, this, reader);
koreoSets = reader.ReadArrayOf((r) => SmartPtr <WwiseKoreographySet> .Read(ObjectInfo.ParentFile, this, r));
levelData = reader.ReadArrayOf((r) => SmartPtr <LevelData> .Read(ObjectInfo.ParentFile, this, r));
}
public override void Parse(AssetsReader reader)
{
base.ParseBase(reader);
PackID = reader.ReadString();
PackName = reader.ReadString();
CoverImage = SmartPtr <SpriteObject> .Read(ObjectInfo.ParentFile, this, reader);
BeatmapLevelCollection = SmartPtr <BeatmapLevelCollectionObject> .Read(ObjectInfo.ParentFile, this, reader);
}
public override void ParseObject(AssetsReader reader)
{
duration = reader.ReadSingle();
localStartingPoint = new WorldPoint(reader);
localEndingPoint = new WorldPoint(reader);
sequence = SmartPtr <EnemySequence> .Read(ObjectInfo.ParentFile, this, reader);
sequenceStartTime = reader.ReadSingle();
}
static CardSetEvaluator()
{
_LutCardMaskPtr = UnmanagedMemory.AllocHGlobalExSmartPtr(StdDeck.Descriptor.Size * sizeof(UInt64));
pLutCardMask = (UInt64 *)_LutCardMaskPtr;
for (int i = 0; i < StdDeck.Descriptor.Size; ++i)
{
pLutCardMask[i] = StdDeck.Descriptor.CardSets[i].bits;
}
}
protected override void Parse(AssetsReader reader)
{
base.Parse(reader);
PackID = reader.ReadString();
PackName = reader.ReadString();
CoverImage = SmartPtr <SpriteObject> .Read(ObjectInfo.ParentFile, this, reader);
IsPackAlwaysOwned = reader.ReadBoolean();
BeatmapLevelCollection = SmartPtr <BeatmapLevelCollectionObject> .Read(ObjectInfo.ParentFile, this, reader);
}
protected override void Parse(AssetsReader reader)
{
base.Parse(reader);
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
BeatmapLevels.Add(SmartPtr <BeatmapLevelDataObject> .Read(ObjectInfo.ParentFile, this, reader));
}
}
public override void ParseObject(AssetsReader reader)
{
distance = reader.ReadEnum <Distance>();
placement = new Vector2F(reader);
toughness = reader.ReadEnum <EnemyToughness>();
enemyOffset = new WorldPoint(reader);
enemySequence = SmartPtr <EnemySequence> .Read(ObjectInfo.ParentFile, this, reader);
ignoreForLevelRank = reader.ReadBoolean();
reader.AlignTo(4);
}
public override void ParseObject(AssetsReader reader)
{
SourceClip = SmartPtr <AudioClipObject> .Read(ObjectInfo.ParentFile, this, reader);
SourceClipPath = reader.ReadString();
SampleRate = reader.ReadInt32();
IgnoreLatencyOffset = reader.ReadBoolean();
reader.AlignTo(4);
TempoSections = reader.ReadArrayOf((r) => new TempoSectionDef(ObjectInfo, r, true));
Tracks = reader.ReadArrayOf((r) => SmartPtr <KoreographyTrackBase> .Read(ObjectInfo.ParentFile, this, r));
}
void DoTestSetMemory(int byteSize, byte value)
{
using (SmartPtr p = UnmanagedMemory.AllocHGlobalExSmartPtr(byteSize))
{
UnmanagedMemory.SetMemory(p.Ptr, byteSize, value);
for (int i = 0; i < byteSize; ++i)
{
Assert.AreEqual(value, ((byte *)p)[i]);
}
}
}
public override void Parse(AssetsReader reader)
{
base.ParseBase(reader);
Icon = SmartPtr <SpriteObject> .Read(ObjectInfo.ParentFile, this, reader);
HintText = reader.ReadString();
CharacteristicName = reader.ReadString();
SerializedName = reader.ReadString();
CompoundIdPartName = reader.ReadString();
SortingOrder = reader.ReadInt32();
}
public override void ParseObject(AssetsReader reader)
{
base.ParseObject(reader);
quality = reader.ReadEnum <SkinQuality>();
updateWhenOffScreen = reader.ReadBoolean();
reader.AlignTo(4);
rootBone = SmartPtr <Transform> .Read(ObjectInfo.ParentFile, this, reader);
bones = reader.ReadArrayOf((r) => SmartPtr <Transform> .Read(ObjectInfo.ParentFile, this, r));
sharedMesh = SmartPtr <MeshObject> .Read(ObjectInfo.ParentFile, this, reader);
}
public override void ParseObject(AssetsReader reader)
{
level = SmartPtr <LevelData> .Read(ObjectInfo.ParentFile, this, reader);
difficulty = reader.ReadEnum <Difficulty>();
koreography = SmartPtr <Koreography> .Read(ObjectInfo.ParentFile, this, reader);
playerSpeed = reader.ReadSingle();
beatTimes = reader.ReadArrayOf((r) => r.ReadSingle());
beats = reader.ReadArrayOf((r) => new BeatData(ObjectInfo, r, true));
}
public static bool GetFileNameFromHandle(IntPtr handle, out string fileName)
{
int[] length = { 0x2000 }; // 512 bytes
using (SmartPtr sptr = new SmartPtr())
{
sptr.Allocate(length[0]);
HandleFlag flag;
if (!NativeMethods.GetHandleInformation(handle, out flag))
{
fileName = null;
return(false);
}
if (flag != HandleFlag.None)
{
fileName = null;
return(false);
}
NtStatus ret = default(NtStatus);
ThreadStart threadStart = delegate
{
ret = NativeMethods.NtQueryObject(handle, ObjectInformationClass.ObjectNameInformation,
sptr.Pointer, length[0], out length[0]);
};
Thread thread = new Thread(threadStart);
thread.Start();
bool result = thread.Join(100);
if (!result)
{
fileName = null;
return(false);
}
if (ret == NtStatus.BufferOverflow)
{
sptr.ReAllocate(length[0]);
ret = NativeMethods.NtQueryObject(handle, ObjectInformationClass.ObjectNameInformation, sptr.Pointer,
length[0], out length[0]);
}
if (ret == NtStatus.Success)
{
ObjectNameInformation oti =
(ObjectNameInformation)Marshal.PtrToStructure(sptr.Pointer, typeof(ObjectNameInformation));
UnicodeString unicodeName = oti.Name;
fileName = unicodeName.GetValue();
return(fileName.Length != 0);
}
}
fileName = string.Empty;
return(false);
}
