mirror of
https://github.com/goatcorp/Dalamud.git
synced 2025-12-12 18:27:23 +01:00
5021 lines
157 KiB
C#
Generated
5021 lines
157 KiB
C#
Generated
// ------------------------------------------------------------------------------
|
|
// <auto-generated>
|
|
// This code was generated by a tool.
|
|
//
|
|
// Changes to this file may cause incorrect behavior and will be lost if
|
|
// the code is regenerated.
|
|
// </auto-generated>
|
|
// ------------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using HexaGen.Runtime;
|
|
using System.Numerics;
|
|
using Dalamud.Bindings.ImGui;
|
|
|
|
namespace Dalamud.Bindings.ImGuizmo
|
|
{
|
|
public unsafe partial class ImGuizmo
|
|
{
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void SetDrawlistNative(ImDrawList* drawlist)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<ImDrawList*, void>)funcTable[0])(drawlist);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, void>)funcTable[0])((nint)drawlist);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetDrawlist(ImDrawListPtr drawlist)
|
|
{
|
|
SetDrawlistNative(drawlist);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetDrawlist()
|
|
{
|
|
SetDrawlistNative((ImDrawList*)(default));
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetDrawlist(ref ImDrawList drawlist)
|
|
{
|
|
fixed (ImDrawList* pdrawlist = &drawlist)
|
|
{
|
|
SetDrawlistNative((ImDrawList*)pdrawlist);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void BeginFrameNative()
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<void>)funcTable[1])();
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<void>)funcTable[1])();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void BeginFrame()
|
|
{
|
|
BeginFrameNative();
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void SetImGuiContextNative(ImGuiContext* ctx)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<ImGuiContext*, void>)funcTable[2])(ctx);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, void>)funcTable[2])((nint)ctx);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetImGuiContext(ImGuiContextPtr ctx)
|
|
{
|
|
SetImGuiContextNative(ctx);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetImGuiContext(ref ImGuiContext ctx)
|
|
{
|
|
fixed (ImGuiContext* pctx = &ctx)
|
|
{
|
|
SetImGuiContextNative((ImGuiContext*)pctx);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte IsOverNative()
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte>)funcTable[3])();
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[3])();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool IsOver()
|
|
{
|
|
byte ret = IsOverNative();
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte IsUsingNative()
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte>)funcTable[4])();
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[4])();
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool IsUsing()
|
|
{
|
|
byte ret = IsUsingNative();
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void EnableNative(byte enable)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<byte, void>)funcTable[5])(enable);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<byte, void>)funcTable[5])(enable);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void Enable(bool enable)
|
|
{
|
|
EnableNative(enable ? (byte)1 : (byte)0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void DecomposeMatrixToComponentsNative(float* matrix, float* translation, float* rotation, float* scale)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<float*, float*, float*, float*, void>)funcTable[6])(matrix, translation, rotation, scale);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, nint, nint, nint, void>)funcTable[6])((nint)matrix, (nint)translation, (nint)rotation, (nint)scale);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(float* matrix, float* translation, float* rotation, float* scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative(matrix, translation, rotation, scale);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref Matrix4x4 matrix, ref Matrix4x4 translation, ref Matrix4x4 rotation, ref Matrix4x4 scale)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
fixed (Matrix4x4* ptranslation = &translation)
|
|
{
|
|
fixed (Matrix4x4* protation = &rotation)
|
|
{
|
|
fixed (Matrix4x4* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, (float*)protation, (float*)pscale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref float matrix, float* translation, float* rotation, float* scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, translation, rotation, scale);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(float* matrix, ref float translation, float* rotation, float* scale)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
DecomposeMatrixToComponentsNative(matrix, (float*)ptranslation, rotation, scale);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, float* rotation, float* scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, rotation, scale);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(float* matrix, float* translation, ref float rotation, float* scale)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
DecomposeMatrixToComponentsNative(matrix, translation, (float*)protation, scale);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref float matrix, float* translation, ref float rotation, float* scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, translation, (float*)protation, scale);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(float* matrix, ref float translation, ref float rotation, float* scale)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
DecomposeMatrixToComponentsNative(matrix, (float*)ptranslation, (float*)protation, scale);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, ref float rotation, float* scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, (float*)protation, scale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(float* matrix, float* translation, float* rotation, ref float scale)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative(matrix, translation, rotation, (float*)pscale);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref float matrix, float* translation, float* rotation, ref float scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, translation, rotation, (float*)pscale);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(float* matrix, ref float translation, float* rotation, ref float scale)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative(matrix, (float*)ptranslation, rotation, (float*)pscale);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, float* rotation, ref float scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, rotation, (float*)pscale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(float* matrix, float* translation, ref float rotation, ref float scale)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative(matrix, translation, (float*)protation, (float*)pscale);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref float matrix, float* translation, ref float rotation, ref float scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, translation, (float*)protation, (float*)pscale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(float* matrix, ref float translation, ref float rotation, ref float scale)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative(matrix, (float*)ptranslation, (float*)protation, (float*)pscale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, ref float rotation, ref float scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
DecomposeMatrixToComponentsNative((float*)pmatrix, (float*)ptranslation, (float*)protation, (float*)pscale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void RecomposeMatrixFromComponentsNative(float* translation, float* rotation, float* scale, float* matrix)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<float*, float*, float*, float*, void>)funcTable[7])(translation, rotation, scale, matrix);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, nint, nint, nint, void>)funcTable[7])((nint)translation, (nint)rotation, (nint)scale, (nint)matrix);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(float* translation, float* rotation, float* scale, float* matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative(translation, rotation, scale, matrix);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref Matrix4x4 translation, ref Matrix4x4 rotation, ref Matrix4x4 scale, ref Matrix4x4 matrix)
|
|
{
|
|
fixed (Matrix4x4* ptranslation = &translation)
|
|
{
|
|
fixed (Matrix4x4* protation = &rotation)
|
|
{
|
|
fixed (Matrix4x4* pscale = &scale)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, (float*)pscale, (float*)pmatrix);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref float translation, float* rotation, float* scale, float* matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, rotation, scale, matrix);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(float* translation, ref float rotation, float* scale, float* matrix)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
RecomposeMatrixFromComponentsNative(translation, (float*)protation, scale, matrix);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, float* scale, float* matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, scale, matrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(float* translation, float* rotation, ref float scale, float* matrix)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
RecomposeMatrixFromComponentsNative(translation, rotation, (float*)pscale, matrix);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref float translation, float* rotation, ref float scale, float* matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, rotation, (float*)pscale, matrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(float* translation, ref float rotation, ref float scale, float* matrix)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
RecomposeMatrixFromComponentsNative(translation, (float*)protation, (float*)pscale, matrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, ref float scale, float* matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, (float*)pscale, matrix);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(float* translation, float* rotation, float* scale, ref float matrix)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative(translation, rotation, scale, (float*)pmatrix);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref float translation, float* rotation, float* scale, ref float matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, rotation, scale, (float*)pmatrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(float* translation, ref float rotation, float* scale, ref float matrix)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative(translation, (float*)protation, scale, (float*)pmatrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, float* scale, ref float matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, scale, (float*)pmatrix);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(float* translation, float* rotation, ref float scale, ref float matrix)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative(translation, rotation, (float*)pscale, (float*)pmatrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref float translation, float* rotation, ref float scale, ref float matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, rotation, (float*)pscale, (float*)pmatrix);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(float* translation, ref float rotation, ref float scale, ref float matrix)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative(translation, (float*)protation, (float*)pscale, (float*)pmatrix);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, ref float scale, ref float matrix)
|
|
{
|
|
fixed (float* ptranslation = &translation)
|
|
{
|
|
fixed (float* protation = &rotation)
|
|
{
|
|
fixed (float* pscale = &scale)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
RecomposeMatrixFromComponentsNative((float*)ptranslation, (float*)protation, (float*)pscale, (float*)pmatrix);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void SetRectNative(float x, float y, float width, float height)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<float, float, float, float, void>)funcTable[8])(x, y, width, height);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<float, float, float, float, void>)funcTable[8])(x, y, width, height);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetRect(float x, float y, float width, float height)
|
|
{
|
|
SetRectNative(x, y, width, height);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void SetOrthographicNative(byte isOrthographic)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<byte, void>)funcTable[9])(isOrthographic);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<byte, void>)funcTable[9])(isOrthographic);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void SetOrthographic(bool isOrthographic)
|
|
{
|
|
SetOrthographicNative(isOrthographic ? (byte)1 : (byte)0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void DrawCubesNative(float* view, float* projection, float* matrices, int matrixCount)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<float*, float*, float*, int, void>)funcTable[10])(view, projection, matrices, matrixCount);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, nint, nint, int, void>)funcTable[10])((nint)view, (nint)projection, (nint)matrices, matrixCount);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(float* view, float* projection, float* matrices, int matrixCount)
|
|
{
|
|
DrawCubesNative(view, projection, matrices, matrixCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(ref Matrix4x4 view, ref Matrix4x4 projection, Matrix4x4[] matrices, int matrixCount)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrices = matrices)
|
|
{
|
|
DrawCubesNative((float*)pview, (float*)pprojection, (float*)pmatrices, matrixCount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(ref Matrix4x4 view, ref Matrix4x4 projection, ref Matrix4x4 matrices, int matrixCount)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrices = &matrices)
|
|
{
|
|
DrawCubesNative((float*)pview, (float*)pprojection, (float*)pmatrices, matrixCount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(ref float view, float* projection, float* matrices, int matrixCount)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
DrawCubesNative((float*)pview, projection, matrices, matrixCount);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(float* view, ref float projection, float* matrices, int matrixCount)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
DrawCubesNative(view, (float*)pprojection, matrices, matrixCount);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(ref float view, ref float projection, float* matrices, int matrixCount)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
DrawCubesNative((float*)pview, (float*)pprojection, matrices, matrixCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(float* view, float* projection, ref float matrices, int matrixCount)
|
|
{
|
|
fixed (float* pmatrices = &matrices)
|
|
{
|
|
DrawCubesNative(view, projection, (float*)pmatrices, matrixCount);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(ref float view, float* projection, ref float matrices, int matrixCount)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrices = &matrices)
|
|
{
|
|
DrawCubesNative((float*)pview, projection, (float*)pmatrices, matrixCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(float* view, ref float projection, ref float matrices, int matrixCount)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrices = &matrices)
|
|
{
|
|
DrawCubesNative(view, (float*)pprojection, (float*)pmatrices, matrixCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawCubes(ref float view, ref float projection, ref float matrices, int matrixCount)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrices = &matrices)
|
|
{
|
|
DrawCubesNative((float*)pview, (float*)pprojection, (float*)pmatrices, matrixCount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void DrawGridNative(float* view, float* projection, float* matrix, float gridSize)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<float*, float*, float*, float, void>)funcTable[11])(view, projection, matrix, gridSize);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, nint, nint, float, void>)funcTable[11])((nint)view, (nint)projection, (nint)matrix, gridSize);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(float* view, float* projection, float* matrix, float gridSize)
|
|
{
|
|
DrawGridNative(view, projection, matrix, gridSize);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(ref Matrix4x4 view, ref Matrix4x4 projection, ref Matrix4x4 matrix, float gridSize)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
DrawGridNative((float*)pview, (float*)pprojection, (float*)pmatrix, gridSize);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(ref float view, float* projection, float* matrix, float gridSize)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
DrawGridNative((float*)pview, projection, matrix, gridSize);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(float* view, ref float projection, float* matrix, float gridSize)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
DrawGridNative(view, (float*)pprojection, matrix, gridSize);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(ref float view, ref float projection, float* matrix, float gridSize)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
DrawGridNative((float*)pview, (float*)pprojection, matrix, gridSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(float* view, float* projection, ref float matrix, float gridSize)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
DrawGridNative(view, projection, (float*)pmatrix, gridSize);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(ref float view, float* projection, ref float matrix, float gridSize)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
DrawGridNative((float*)pview, projection, (float*)pmatrix, gridSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(float* view, ref float projection, ref float matrix, float gridSize)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
DrawGridNative(view, (float*)pprojection, (float*)pmatrix, gridSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void DrawGrid(ref float view, ref float projection, ref float matrix, float gridSize)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
DrawGridNative((float*)pview, (float*)pprojection, (float*)pmatrix, gridSize);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte ManipulateNative(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<float*, float*, ImGuizmoOperation, ImGuizmoMode, float*, float*, float*, float*, float*, byte>)funcTable[12])(view, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<nint, nint, ImGuizmoOperation, ImGuizmoMode, nint, nint, nint, nint, nint, byte>)funcTable[12])((nint)view, (nint)projection, operation, mode, (nint)matrix, (nint)deltaMatrix, (nint)snap, (nint)localBounds, (nint)boundsSnap);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref Matrix4x4 deltaMatrix, ref float snap, ref float localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
fixed (Matrix4x4* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref Matrix4x4 deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
fixed (Matrix4x4* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, default);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref Matrix4x4 deltaMatrix, ref float snap)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
fixed (Matrix4x4* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, default, default);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref Matrix4x4 deltaMatrix)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
fixed (Matrix4x4* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, default, default, default);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, default, default, default, default);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref float snap)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, default, (float*)psnap, default, default);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, default, (float*)psnap, (float*)plocalBounds, default);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref Matrix4x4 view, ref Matrix4x4 projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref Matrix4x4 matrix, ref float snap, ref float localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (Matrix4x4* pview = &view)
|
|
{
|
|
fixed (Matrix4x4* pprojection = &projection)
|
|
{
|
|
fixed (Matrix4x4* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, default, (float*)psnap, (float*)plocalBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)(default), (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)(default), (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)(default), (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, float* boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, boundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* plocalBounds = &localBounds)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, (float*)plocalBounds, (float*)(default));
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, float* snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, snap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, float* deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, deltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, float* matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, matrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, float* projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, projection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(float* view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative(view, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool Manipulate(ref float view, ref float projection, ImGuizmoOperation operation, ImGuizmoMode mode, ref float matrix, ref float deltaMatrix, ref float snap, float* localBounds, ref float boundsSnap)
|
|
{
|
|
fixed (float* pview = &view)
|
|
{
|
|
fixed (float* pprojection = &projection)
|
|
{
|
|
fixed (float* pmatrix = &matrix)
|
|
{
|
|
fixed (float* pdeltaMatrix = &deltaMatrix)
|
|
{
|
|
fixed (float* psnap = &snap)
|
|
{
|
|
fixed (float* pboundsSnap = &boundsSnap)
|
|
{
|
|
byte ret = ManipulateNative((float*)pview, (float*)pprojection, operation, mode, (float*)pmatrix, (float*)pdeltaMatrix, (float*)psnap, localBounds, (float*)pboundsSnap);
|
|
return ret != 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|