protected void ExtraV2Mangle(byte *buffer1, byte codeExtra)
{
var gDataTmp = new byte[20 + 0xA0];
fixed(byte *buffer2 = gDataTmp) // aligned
{
PointerUtils.Memcpy(buffer2 + 20, buffer1, 0xA0);
var pl2 = (uint *)buffer2;
pl2[0] = 5;
pl2[1] = pl2[2] = 0;
pl2[3] = codeExtra;
pl2[4] = 0xA0;
var ret = _kirk.HleUtilsBufferCopyWithRange(
buffer2,
20 + 0xA0,
buffer2,
20 + 0xA0,
Kirk.CommandEnum.PspKirkCmdDecrypt
);
if (ret != 0)
{
throw new Exception($"extra de-mangle returns {ret}, ");
}
// copy result back
PointerUtils.Memcpy(buffer1, buffer2, 0xA0);
}
}
private void pointersUpdatedHandler(object sender, PointerEventArgs pointerEventArgs)
{
var over = pointers.Count;
var p = pointerEventArgs.Pointers;
var count = p.Count;
for (var i = 0; i < count; i++)
{
var pointer = p[i];
if ((pointer.Buttons & Pointer.PointerButtonState.AnyButtonPressed) != 0)
{
continue; // we ignore pressed pointers
}
if (PointerUtils.IsPointerOnTarget(pointer, transform))
{
pointers.Add(pointer.Id);
}
else
{
pointers.Remove(pointer.Id);
}
}
if (over == 0 && pointers.Count > 0)
{
dispatchOver();
}
else if (over > 0 && pointers.Count == 0)
{
dispatchOut();
}
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="size"></param>
public static void DecryptAes(byte[] key, byte *input, byte *output, int size)
{
var inputArray = PointerUtils.PointerToByteArray(input, size);
var outputArray = DecryptAes(inputArray, key);
PointerUtils.ByteArrayToPointer(outputArray, output);
}
private IEnumerator TestRaysWorker()
{
PointerStateContainer lineOn = new PointerStateContainer()
{
GazePointerEnabled = false,
GGVPointerEnabled = null,
PokePointerEnabled = false,
SpherePointerEnabled = false,
LinePointerEnabled = true
};
TestHand rightHand = new TestHand(Handedness.Right);
TestHand leftHand = new TestHand(Handedness.Left);
yield return(rightHand.Show(Vector3.zero));
yield return(leftHand.Show(Vector3.zero));
TestContext.Out.WriteLine("Show both hands");
EnsurePointerStates(Handedness.Right, lineOn);
EnsurePointerStates(Handedness.Left, lineOn);
TestContext.Out.WriteLine("Turn off ray pointer both hands");
PointerUtils.SetHandRayPointerBehavior(PointerBehavior.AlwaysOff);
yield return(null);
PointerStateContainer lineOff = new PointerStateContainer()
{
GazePointerEnabled = false,
GGVPointerEnabled = null,
PokePointerEnabled = false,
SpherePointerEnabled = false,
LinePointerEnabled = false
};
EnsurePointerStates(Handedness.Right, lineOff);
EnsurePointerStates(Handedness.Left, lineOff);
TestContext.Out.WriteLine("Turn on ray right hand.");
PointerUtils.SetHandRayPointerBehavior(PointerBehavior.AlwaysOn, Handedness.Right);
yield return(null);
EnsurePointerStates(Handedness.Right, lineOn);
EnsurePointerStates(Handedness.Left, lineOff);
TestContext.Out.WriteLine("Turn on ray (default behavior) right hand.");
PointerUtils.SetHandRayPointerBehavior(PointerBehavior.Default, Handedness.Right);
yield return(null);
EnsurePointerStates(Handedness.Right, lineOn);
EnsurePointerStates(Handedness.Left, lineOff);
TestContext.Out.WriteLine("Turn on ray (default behavior) left hand.");
PointerUtils.SetHandRayPointerBehavior(PointerBehavior.Default, Handedness.Left);
yield return(null);
EnsurePointerStates(Handedness.Right, lineOn);
EnsurePointerStates(Handedness.Left, lineOn);
}
public static T SafeRead <T>(Pointer <T> ptr, int elemOfs = 0)
{
T t = default;
IntPtr addr = PointerUtils.Offset <T>(ptr.Address, elemOfs);
if (Assertion.Throws <NullReferenceException>(delegate { t = CSUnsafe.Read <T>(addr.ToPointer()); }))
{
return(default);
/// <summary>
/// ハンドレイをOffにする
/// </summary>
public void HandRayOff()
{
// Turn off all hand rays
PointerUtils.SetHandRayPointerBehavior(PointerBehavior.AlwaysOff);
// Turn off hand rays for the right hand only
//PointerUtils.SetHandRayPointerBehavior(PointerBehavior.AlwaysOff, Handedness.Right);
}
public int sceMpegQueryStreamSize(byte *pmfHeader, out uint size)
{
var pmf = new Pmf().Load(new MemoryStream(PointerUtils.PointerToByteArray(pmfHeader, 2048)));
size = pmf.Header.StreamSize;
//*Size = 0;
return(0);
}
public static string StringFromAddress(CpuThreadState CpuThreadState, uint Address)
{
if (Address == 0)
{
return(null);
}
return(PointerUtils.PtrToString((byte *)CpuThreadState.GetMemoryPtr(Address), Encoding.UTF8));
}
public int sceMp3NotifyAddStreamData(Mp3Stream Mp3Stream, int Size)
{
Mp3Stream.AddStreamData(
PointerUtils.PointerToByteArray(
(byte *)Mp3Stream.Mp3Arguments->Mp3BufferPointer.GetPointer(Memory, Size), Size)
);
return(0);
}
public int sceNetAdhocMatchingGetHelloOpt(Matching Matching, ref int DataLength, byte *DataPointer)
{
var Data = Matching.GetHelloOpt();
DataLength = Math.Min(Data.Length, DataLength);
PointerUtils.Memcpy(DataPointer, Data, DataLength);
return(0);
}
/// <summary>
/// Sets pointer behavior to mimic HoloLens 2
/// PokePointer will be Default
/// GrabPointer will be Default
/// HandRayPointer will be Default
/// MotionControllerRayPointer will be off
/// GazePointer will be Off
/// </summary>
public void SetHoloLens2()
{
PointerUtils.SetHandPokePointerBehavior(PointerBehavior.Default, Handedness.Any);
PointerUtils.SetHandGrabPointerBehavior(PointerBehavior.Default, Handedness.Any);
PointerUtils.SetHandRayPointerBehavior(PointerBehavior.Default, Handedness.Any);
PointerUtils.SetMotionControllerRayPointerBehavior(PointerBehavior.AlwaysOff, Handedness.Any);
PointerUtils.SetGazePointerBehavior(PointerBehavior.AlwaysOff);
}
public void FindLargestMatchByte1()
{
var A = new byte[] { 1, 0, 2, 2, 2 };
fixed(byte *_A = A)
{
Assert.AreEqual(1, PointerUtils.FindLargestMatchByte(_A, (byte)1, A.Length - 3));
}
}
public int sceNetInetRecv(int SocketId, void *BufferPointer, int BufferLength, SocketFlags Flags)
{
var Socket = Sockets.Get(SocketId);
var RecvBuffer = new byte[BufferLength];
int Received = Socket.Receive(RecvBuffer, Flags);
PointerUtils.Memcpy((byte *)BufferPointer, RecvBuffer, Received);
return(Received);
}
public void FindLargestMatchByte13()
{
var A = new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };
fixed(byte *_A = A)
{
Assert.Equal(13, PointerUtils.FindLargestMatchByte(_A, (byte)1, A.Length));
}
}
public int sceKernelUtilsSha1Digest(byte *Data, uint Size, byte *Digest)
{
PointerUtils.Memcpy(
Digest,
SHA1.Create().ComputeHash(PointerUtils.PointerToByteArray(Data, (int)Size)),
20
);
return(0);
}
public void FindLargestMatchByte3()
{
var A = new byte[] { 3, 3, 3 };
fixed(byte *_A = A)
{
Assert.Equal(3, PointerUtils.FindLargestMatchByte(_A, (byte)3, A.Length));
}
}
public unsafe int IoRead(HleIoDrvFileArg HleIoDrvFileArg, byte *OutputPointer, int OutputLength)
{
var IsoFileArgument = ((IsoFileArgument)HleIoDrvFileArg.FileArgument);
var OutputData = new byte[OutputLength];
int Readed = IsoFileArgument.Stream.Read(OutputData, 0, OutputLength);
PointerUtils.Memcpy(OutputPointer, OutputData, OutputLength);
return(Readed);
//throw new NotImplementedException();
}
public unsafe void ChainingValue(uint *result)
{
var full = new uint[16];
fixed(uint *ptrFull = full)
{
Compress(ptrFull);
PointerUtils.MemMove(&result[0], ptrFull, 8 * sizeof(uint));
}
}
public Font sceFontOpenUserMemory(FontLibrary FontLibrary, byte *MemoryFontAddress, int MemoryFontLength,
uint *ErrorCode)
{
var MemoryFont = PointerUtils.PointerToByteArray(MemoryFontAddress, MemoryFontLength);
var PGF = new Pgf().Load(new MemoryStream(MemoryFont));
var Font = new Font(FontLibrary, PGF);
*ErrorCode = 0;
return(Font);
}
public void TestMemset()
{
var Data = new byte[131];
PointerUtils.Memset(Data, 0x3E, Data.Length);
Assert.Equal(
((byte)0x3E).Repeat(Data.Length),
Data
);
}
private void SetToggleHelper <T>(Interactable toggle, string toggleName, InputSourceType inputType) where T : class, IMixedRealityPointer
{
if (toggle == null)
{
Debug.LogWarning($"Button {toggleName} is null on GameObject {gameObject.name}. Did you forget to set it?");
}
else
{
toggle.IsToggled = PointerUtils.GetPointerBehavior <T>(Handedness.Any, inputType) != PointerBehavior.AlwaysOff;
}
}
private static void UnswizzleInline(void *data, int rowWidth, int textureHeight)
{
var temp = new byte[rowWidth * textureHeight];
fixed(void *tempPointer = temp)
{
Unswizzle(data, tempPointer, rowWidth, textureHeight);
}
PointerUtils.Memcpy((byte *)data, temp, rowWidth * textureHeight);
}
public uint sceKernelMemset(uint PspPointer, int Data, int Size)
{
try
{
PointerUtils.Memset((byte *)Memory.PspAddressToPointerSafe(PspPointer, Size), (byte)Data, Size);
}
catch
{
}
return(PspPointer);
}
public void FindLargestMatch5()
{
var A = new byte[] { 1, 2, 3, 4, 5, 0, 7 };
var B = new byte[] { 1, 2, 3, 4, 5, 6, 7 };
fixed(byte *_A = A)
fixed(byte *_B = B)
{
Assert.Equal(5, PointerUtils.FindLargestMatch(_A, _B, A.Length));
}
}
public void FindLargestMatch0()
{
var A = new byte[] { 0, 2, 3, 4, 5, 6, 7 };
var B = new byte[] { 1, 2, 3, 4, 5, 6, 7 };
fixed(byte *_A = A)
fixed(byte *_B = B)
{
Assert.Equal(0, PointerUtils.FindLargestMatch(_A, _B, 5));
}
}
public void FastHash()
{
var A = new byte[] { 1, 2, 3 };
var B = new byte[] { 1, 2, 4 };
fixed(byte *_A = A)
fixed(byte *_B = B)
{
Assert.NotEqual(PointerUtils.FastHash(_A, 3), PointerUtils.FastHash(_B, 3));
}
}
public int sceMpegCreate(SceMpegPointer *sceMpegPointer, void *mpegData, int mpegSize,
SceMpegRingbuffer *sceMpegRingbuffer, int frameWidth, int mode, int ddrTop)
{
//return -1;
var mpeg = GetMpeg(sceMpegPointer);
if (mpegSize < sceMpegQueryMemSize(0))
{
throw (new SceKernelException(SceKernelErrors.ERROR_MPEG_NO_MEMORY));
}
// Update the ring buffer struct.
if (sceMpegRingbuffer->PacketSize == 0)
{
sceMpegRingbuffer->PacketsAvailable = 0;
}
else
{
sceMpegRingbuffer->PacketsAvailable =
(int)((sceMpegRingbuffer->DataEnd.Address - sceMpegRingbuffer->Data.Address) /
sceMpegRingbuffer->PacketSize);
}
sceMpegRingbuffer->SceMpeg = Memory.PointerToPspPointer(sceMpegPointer);
SceMpeg *sceMpegData = (SceMpeg *)(((byte *)mpegData) + 0x30);
sceMpegPointer->SceMpeg = Memory.PointerToPspPointer(sceMpegData);
PointerUtils.StoreStringOnPtr("LIBMPEG", Encoding.UTF8, sceMpegData->MagicBytes);
PointerUtils.StoreStringOnPtr("001", Encoding.UTF8, sceMpegData->VersionBytes);
sceMpegData->Pad = -1;
sceMpegData->RingBufferAddress = Memory.PointerToPspPointer(sceMpegRingbuffer);
sceMpegData->RingBufferAddressDataUpper = sceMpegRingbuffer->DataEnd;
sceMpegData->FrameWidth = frameWidth;
sceMpegData->SceMpegAvcMode.Mode = -1;
sceMpegData->SceMpegAvcMode.PixelFormat = GuPixelFormats.Rgba8888;
sceMpegData->VideoFrameCount = 0;
sceMpegData->AudioFrameCount = 0;
sceMpegRingbuffer->PacketsTotal = 0;
mpeg.ReadPackets = numPackets => (int)HleInterop.ExecuteFunctionNow(sceMpegRingbuffer->Callback,
sceMpegRingbuffer->Data,
numPackets, sceMpegRingbuffer->CallbackParameter);
mpeg._Mpeg = sceMpegPointer;
mpeg.Data = sceMpegData;
mpeg.Create();
return(0);
}
public IEnumerator TestGrab()
{
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.AddComponent <NearInteractionGrabbable>();
cube.transform.position = Vector3.forward;
TestUtilities.PlayspaceToOriginLookingForward();
TestHand rightHand = new TestHand(Handedness.Right);
TestHand leftHand = new TestHand(Handedness.Left);
TestContext.Out.WriteLine("Show both hands near grabbable cube");
yield return(rightHand.Show(cube.transform.position));
yield return(leftHand.Show(cube.transform.position));
yield return(PlayModeTestUtilities.WaitForInputSystemUpdate());
PointerStateContainer grabOn = new PointerStateContainer()
{
GazePointerEnabled = false,
GGVPointerEnabled = null,
PokePointerEnabled = false,
SpherePointerEnabled = true,
LinePointerEnabled = false
};
EnsurePointerStates(Handedness.Right, grabOn);
EnsurePointerStates(Handedness.Left, grabOn);
TestContext.Out.WriteLine("Turn off grab pointer right hand");
PointerUtils.SetHandGrabPointerBehavior(PointerBehavior.AlwaysOff, Handedness.Right);
yield return(null);
PointerStateContainer grabOff = new PointerStateContainer()
{
GazePointerEnabled = false,
GGVPointerEnabled = null,
PokePointerEnabled = false,
SpherePointerEnabled = false,
LinePointerEnabled = true
};
EnsurePointerStates(Handedness.Right, grabOff);
EnsurePointerStates(Handedness.Left, grabOn);
TestContext.Out.WriteLine("Turn off grab pointer both hands");
PointerUtils.SetHandGrabPointerBehavior(PointerBehavior.AlwaysOff);
yield return(null);
EnsurePointerStates(Handedness.Right, grabOff);
EnsurePointerStates(Handedness.Left, grabOff);
}
private static unsafe byte[] GetInitialHashLong(byte[] initialHash, byte[] appendix)
{
var result = new byte[ARGON2_PREHASH_SEED_LENGTH];
fixed(byte *initialHashPtr = initialHash, resultPtr = result, appendixPtr = appendix)
{
PointerUtils.MemMove(resultPtr, initialHashPtr, ARGON2_PREHASH_DIGEST_LENGTH);
PointerUtils.MemMove(resultPtr + ARGON2_PREHASH_DIGEST_LENGTH, appendixPtr, 4);
}
return(result);
}
public void TestMemcpyOverlapping()
{
var _Data = new byte[] { 1, 0, 0, 0, 0, 0 };
var Expected = new byte[] { 1, 1, 1, 1, 1, 1 };
fixed(byte *Data = _Data)
{
PointerUtils.Memcpy(&Data[1], &Data[0], 5);
}
Assert.Equal(Expected, _Data);
}
