Jump to content
Default Slate Blackcurrant Watermelon Strawberry Orange Banana Apple Emerald Chocolate Marble
Default Slate Blackcurrant Watermelon Strawberry Orange Banana Apple Emerald Chocolate Marble
Sign in to follow this  
Feretorix

Official WeScript.Wrapper API

Recommended Posts

Events:

Renderer.OnRenderer(int fps, EventArgs args) //used for rendering code
Memory.OnTick(int counter, EventArgs args) //with a delay of 33ms between each tick, used for heavy calculation codes which are not frame dependant
Input.OnInput(VirtualKeyCode key, bool isPressed, EventArgs args) //used for monitoring key pressing and releasing

Renderer:

	static Vector2 GetWindowMargins(IntPtr hWnd);
	static Vector2 GetWindowSize(IntPtr hWnd);
	static bool IsGameOnTop(IntPtr hWnd);
	static void ForceGameToBorderless(IntPtr hWnd);

	static void DrawText(System::String^ text, float x, float y);
	static void DrawText(System::String^ text, float x, float y, Color color);
	static void DrawText(System::String^ text, float x, float y, Color color, int size);
	static void DrawText(System::String^ text, float x, float y, Color color, int size, TextAlignment alignment);
	static void DrawText(System::String^ text, float x, float y, Color color, int size, TextAlignment alignment, bool bordered);
	static void DrawText(System::String^ text, Vector2 position);
	static void DrawText(System::String^ text, Vector2 position, Color color);
	static void DrawText(System::String^ text, Vector2 position, Color color, int size);
	static void DrawText(System::String^ text, Vector2 position, Color color, int size, TextAlignment alignment);
	static void DrawText(System::String^ text, Vector2 position, Color color, int size, TextAlignment alignment, bool bordered);

	static Vector2 GetTextWidth(System::String^ text);
	static Vector2 GetTextWidth(System::String^ text, int size);

	static void DrawFilledRect(Vector4 rectPos, Color color);
	static void DrawFilledRect(Vector2 position, Vector2 size, Color color);
	static void DrawFilledRect(float x, float y, float width, float height, Color color);

	static void DrawRect(Vector4 rectPos, Color color);
	static void DrawRect(Vector4 rectPos, float linewidth, Color color);
	static void DrawRect(Vector2 position, Vector2 size, Color color);
	static void DrawRect(Vector2 position, Vector2 size, float linewidth, Color color);
	static void DrawRect(float x, float y, float w, float h, Color color);
	static void DrawRect(float x, float y, float w, float h, float linewidth, Color color);
	
	static void DrawLine(Vector4 twoPointsPos, Color color);
	static void DrawLine(Vector4 twoPointsPos, Color color, float width);
	static void DrawLine(Vector4 twoPointsPos, Color color, float width, bool antialias);
	static void DrawLine(Vector2 startPoint, Vector2 endPoint, Color color);
	static void DrawLine(Vector2 startPoint, Vector2 endPoint, Color color, float width);
	static void DrawLine(Vector2 startPoint, Vector2 endPoint, Color color, float width, bool antialias);
	static void DrawLine(float x1, float y1, float x2, float y2, Color color);
	static void DrawLine(float x1, float y1, float x2, float y2, Color color, float width);
	static void DrawLine(float x1, float y1, float x2, float y2, Color color, float width, bool antialias);

	static void DrawLines(array<float>^ screenPoints, unsigned int ptsCount, Color color);
	static void DrawLines(array<float>^ screenPoints, unsigned int ptsCount, Color color, float width);
	static void DrawLines(array<float>^ screenPoints, unsigned int ptsCount, Color color, float width, bool antialias);

	static void DrawCircle(float x, float y, float radius, Color color);
	static void DrawCircle(float x, float y, float radius, float width, Color color);
	static void DrawCircle(float x, float y, float radius, float width, bool antialias, Color color);
	static void DrawCircle(float x, float y, float radius, float width, bool antialias, float resolution, Color color);
	static void DrawCircle(Vector2 position, float radius, Color color);
	static void DrawCircle(Vector2 position, float radius, float width, Color color);
	static void DrawCircle(Vector2 position, float radius, float width, bool antialias, Color color);
	static void DrawCircle(Vector2 position, float radius, float width, bool antialias, float resolution, Color color);

	static unsigned int CreateSprite(array<System::Byte>^ imageBytes, int length);
	static bool ReleaseSprite(unsigned int index);
	static void ReleaseAllSprites();
	static Vector2 GetSpriteDimensions(array<System::Byte>^ imageBytes, int length);
	static bool DrawSprite(unsigned int index, float x, float y);
	static bool DrawSprite(unsigned int index, float x, float y, Color color);
	static bool DrawSprite(unsigned int index, float x, float y, Color color, float radians);
	static bool DrawSprite(unsigned int index, float x, float y, Color color, float radians, float scale);
	static bool DrawSprite(unsigned int index, float x, float y, Color color, float radians, float scale, Vector4 rectXYWH);
	static bool DrawSprite(unsigned int index, float x, float y, Color color, float radians, float scale, Vector2 rectXY, Vector2 rectWH);
	static bool DrawSprite(unsigned int index, float x, float y, Color color, float radians, float scale, float rectX, float rectY, float rectW, float rectH);
	static bool DrawSprite(unsigned int index, Vector2 position);
	static bool DrawSprite(unsigned int index, Vector2 position, Color color);
	static bool DrawSprite(unsigned int index, Vector2 position, Color color, float radians);
	static bool DrawSprite(unsigned int index, Vector2 position, Color color, float radians, float scale);
	static bool DrawSprite(unsigned int index, Vector2 position, Color color, float radians, float scale, Vector4 rectXYWH);
	static bool DrawSprite(unsigned int index, Vector2 position, Color color, float radians, float scale, Vector2 rectXY, Vector2 rectWH);
	static bool DrawSprite(unsigned int index, Vector2 position, Color color, float radians, float scale, float rectX, float rectY, float rectW, float rectH);

	static void DrawFPSBox(float headX, float headY, float feetX, float feetY, Color color, BoxStance stance);
	static void DrawFPSBox(float headX, float headY, float feetX, float feetY, Color color, BoxStance stance, float thickness);
	static void DrawFPSBox(float headX, float headY, float feetX, float feetY, Color color, BoxStance stance, float thickness, bool border);
	static void DrawFPSBox(float headX, float headY, float feetX, float feetY, Color color, BoxStance stance, float thickness, bool border, bool drawbox, float health, float maxhealth);
	static void DrawFPSBox(float headX, float headY, float feetX, float feetY, Color color, BoxStance stance, float thickness, bool border, bool drawbox, float health, float maxhealth, float armor, float maxarmor);
	static void DrawFPSBox(float headX, float headY, float feetX, float feetY, Color color, BoxStance stance, float thickness, bool border, bool drawbox, float health, float maxhealth, float armor, float maxarmor, int fontSize, System::String^ text);
	static void DrawFPSBox(float headX, float headY, float feetX, float feetY, Color color, BoxStance stance, float thickness, bool border, bool drawbox, float health, float maxhealth, float armor, float maxarmor, int fontSize, System::String^ text1, System::String^ text2, System::String^ text3, System::String^ text4, System::String^ text5);
	static void DrawFPSBox(Vector2 headPos, Vector2 feetPos, Color color, BoxStance stance);
	static void DrawFPSBox(Vector2 headPos, Vector2 feetPos, Color color, BoxStance stance, float thickness);
	static void DrawFPSBox(Vector2 headPos, Vector2 feetPos, Color color, BoxStance stance, float thickness, bool border);
	static void DrawFPSBox(Vector2 headPos, Vector2 feetPos, Color color, BoxStance stance, float thickness, bool border, bool drawbox, float health, float maxhealth);
	static void DrawFPSBox(Vector2 headPos, Vector2 feetPos, Color color, BoxStance stance, float thickness, bool border, bool drawbox, float health, float maxhealth, float armor, float maxarmor);
	static void DrawFPSBox(Vector2 headPos, Vector2 feetPos, Color color, BoxStance stance, float thickness, bool border, bool drawbox, float health, float maxhealth, float armor, float maxarmor, int fontSize, System::String^ text);
	static void DrawFPSBox(Vector2 headPos, Vector2 feetPos, Color color, BoxStance stance, float thickness, bool border, bool drawbox, float health, float maxhealth, float armor, float maxarmor, int fontSize, System::String^ text1, System::String^ text2, System::String^ text3, System::String^ text4, System::String^ text5);

	static bool WorldToScreen(Vector3 worldPos, [Out] Vector2% screenPos, SharpDX::Matrix viewProjectionMatrix, Vector2 windowMargin, Vector2 windowSize, W2SType Value);

	static property unsigned ScreenResolutionX {}
	static property unsigned ScreenResolutionY {}
	static property Device^ Direct3DDevice {}

Input:

	static unsigned int KeyPress(VirtualKeyCode key);
	static unsigned int KeyDown(VirtualKeyCode key);
	static unsigned int KeyUp(VirtualKeyCode key);
	static unsigned int SendString(System::String^ text);
	static void SleepWS(unsigned int sleepTime);
	static IntPtr SendMessageWS(IntPtr hWnd, int Msg, int wParam, IntPtr lParam);
	static IntPtr PostMessageWS(IntPtr hWnd, int Msg, int wParam, IntPtr lParam);
	static unsigned int MapVirtualKeyWS(unsigned int uCode, unsigned int uMapType);
	static void keybd_eventWS(VirtualKeyCode key, System::Byte bScan, KEYEVENTF dwFlags, IntPtr dwExtraInfo);
	static void mouse_eventWS(MouseEventFlags dwFlags, int dx, int dy, MouseEventDataXButtons dwData, IntPtr dwExtraInfo);
	static bool SetCursorPosWS(int x, int y);
	static bool GetCursorPosWS([Out] int% x, [Out] int% y);

Memory:

	static property unsigned __int64 TickCount {}
	static IntPtr FindWindowName(System::String^ WindowName);
	static IntPtr FindWindowClassName(System::String^ ClassName);
	static unsigned int GetPIDFromHWND(IntPtr hWnd);
	static unsigned int GetPIDForProcess(System::String^ ProcessName);
	static IntPtr OpenProcess(unsigned int dwDesiredAccess, unsigned int dwProcessId);
	static bool CloseHandle(IntPtr hObject);
	static bool IsProcess64Bit(IntPtr hProcess);

	static IntPtr GetModule(IntPtr hProcess, System::String^ ModuleName);
	static IntPtr GetModule(IntPtr hProcess, System::String^ ModuleName, bool Is64Bit);

	static IntPtr GetModuleSize(IntPtr hProcess, System::String^ ModuleName);
	static IntPtr GetModuleSize(IntPtr hProcess, System::String^ ModuleName, bool Is64Bit);

	static IntPtr GetModuleEntryPoint(IntPtr hProcess, System::String^ ModuleName);
	static IntPtr GetModuleEntryPoint(IntPtr hProcess, System::String^ ModuleName, bool Is64Bit);

	static IntPtr FindSignature(IntPtr hProcess, IntPtr Address, IntPtr Size, System::String^ Signature, int offset);
	static IntPtr FindSignature(IntPtr hProcess, IntPtr Address, IntPtr Size, System::String^ Signature, int offset, bool returnOffset);
	
	static int FindPossibleMatrix(IntPtr hProcess, IntPtr Address, IntPtr Size, Vector3 worldPos, [Out] array<UInt64>^% addressesFound, int w2sType);

	static IntPtr ReadPointer(IntPtr hProcess, IntPtr Address, bool Is64Bit);
	static IntPtr ReadIntPtr(IntPtr hProcess, IntPtr Address, bool Is64Bit);

	static bool ReadBool(IntPtr hProcess, IntPtr Address);
	static System::Byte ReadByte(IntPtr hProcess, IntPtr Address);
	static Int16 ReadInt16(IntPtr hProcess, IntPtr Address);
	static UInt16 ReadUInt16(IntPtr hProcess, IntPtr Address);
	static UInt16 ReadWORD(IntPtr hProcess, IntPtr Address);
	static INT32 ReadInt32(IntPtr hProcess, IntPtr Address);
	static UINT32 ReadUInt32(IntPtr hProcess, IntPtr Address);
	static UINT32 ReadDWORD(IntPtr hProcess, IntPtr Address);
	static INT64 ReadInt64(IntPtr hProcess, IntPtr Address);
	static UINT64 ReadUInt64(IntPtr hProcess, IntPtr Address);
	static UINT64 ReadDWORD64(IntPtr hProcess, IntPtr Address);
	static float ReadFloat(IntPtr hProcess, IntPtr Address);
	static double ReadDouble(IntPtr hProcess, IntPtr Address);
	static Vector2 ReadVector2(IntPtr hProcess, IntPtr Address);
	static Vector3 ReadVector3(IntPtr hProcess, IntPtr Address);
	static Vector4 ReadVector4(IntPtr hProcess, IntPtr Address);
	static Matrix ReadMatrix(IntPtr hProcess, IntPtr Address);
	static System::String^ ReadString(IntPtr hProcess, IntPtr Address, bool IsUnicode);
	static System::String^ ReadString(IntPtr hProcess, IntPtr Address, bool IsUnicode, int length);
	static bool ReadBytes(IntPtr hProcess, IntPtr Address, array<System::Byte>^% lpBuffer, UInt32 nSize);

	static bool WritePointer(IntPtr hProcess, IntPtr Address, bool Is64Bit, IntPtr value);
	static bool WriteIntPtr(IntPtr hProcess, IntPtr Address, bool Is64Bit, IntPtr value);

	static bool WriteBool(IntPtr hProcess, IntPtr Address, bool value);
	static bool WriteByte(IntPtr hProcess, IntPtr Address, System::Byte value);
	static bool WriteInt16(IntPtr hProcess, IntPtr Address, Int16 value);
	static bool WriteUInt16(IntPtr hProcess, IntPtr Address, UInt16 value);
	static bool WriteWORD(IntPtr hProcess, IntPtr Address, UInt16 value);
	static bool WriteInt32(IntPtr hProcess, IntPtr Address, INT32 value);
	static bool WriteUInt32(IntPtr hProcess, IntPtr Address, UINT32 value);
	static bool WriteDWORD(IntPtr hProcess, IntPtr Address, UINT32 value);
	static bool WriteInt64(IntPtr hProcess, IntPtr Address, INT64 value);
	static bool WriteUInt64(IntPtr hProcess, IntPtr Address, UINT64 value);
	static bool WriteDWORD64(IntPtr hProcess, IntPtr Address, UINT64 value);
	static bool WriteFloat(IntPtr hProcess, IntPtr Address, float value);
	static bool WriteDouble(IntPtr hProcess, IntPtr Address, double value);
	static bool WriteVector2(IntPtr hProcess, IntPtr Address, Vector2 value);
	static bool WriteVector3(IntPtr hProcess, IntPtr Address, Vector3 value);
	static bool WriteVector4(IntPtr hProcess, IntPtr Address, Vector4 value);
	static bool WriteMatrix(IntPtr hProcess, IntPtr Address, Matrix value);
	static bool WriteString(IntPtr hProcess, IntPtr Address, System::String^ text, bool ToUnicode);

//new premium DRIVER API below:

	static bool InitDriver(DriverName drvName);
	static bool ReleaseDriver();
	static IntPtr ZwOpenProcess(unsigned int dwDesiredAccess, unsigned int dwProcessId);
	static IntPtr ZwGetModule(IntPtr hProcess, System::String^ ModuleName, bool Is64Bit);
	static IntPtr ZwGetModuleSize(IntPtr hProcess, System::String^ ModuleName, bool Is64Bit);
	static IntPtr ZwGetModuleEntryPoint(IntPtr hProcess, System::String^ ModuleName, bool Is64Bit);


	static IntPtr ZwReadPointer(IntPtr hProcess, IntPtr Address, bool Is64Bit);
	static IntPtr ZwReadIntPtr(IntPtr hProcess, IntPtr Address, bool Is64Bit);
	static bool ZwReadBool(IntPtr hProcess, IntPtr Address);
	static System::Byte ZwReadByte(IntPtr hProcess, IntPtr Address);
	static Int16 ZwReadInt16(IntPtr hProcess, IntPtr Address);
	static UInt16 ZwReadUInt16(IntPtr hProcess, IntPtr Address);
	static UInt16 ZwReadWORD(IntPtr hProcess, IntPtr Address);
	static INT32 ZwReadInt32(IntPtr hProcess, IntPtr Address);
	static UINT32 ZwReadUInt32(IntPtr hProcess, IntPtr Address);
	static UINT32 ZwReadDWORD(IntPtr hProcess, IntPtr Address);
	static INT64 ZwReadInt64(IntPtr hProcess, IntPtr Address);
	static UINT64 ZwReadUInt64(IntPtr hProcess, IntPtr Address);
	static UINT64 ZwReadDWORD64(IntPtr hProcess, IntPtr Address);
	static float ZwReadFloat(IntPtr hProcess, IntPtr Address);
	static double ZwReadDouble(IntPtr hProcess, IntPtr Address);
	static Vector2 ZwReadVector2(IntPtr hProcess, IntPtr Address);
	static Vector3 ZwReadVector3(IntPtr hProcess, IntPtr Address);
	static Vector4 ZwReadVector4(IntPtr hProcess, IntPtr Address);
	static Matrix ZwReadMatrix(IntPtr hProcess, IntPtr Address);
	static System::String^ ZwReadString(IntPtr hProcess, IntPtr Address, bool IsUnicode);
	static System::String^ ZwReadString(IntPtr hProcess, IntPtr Address, bool IsUnicode, int length);
	static bool ZwReadBytes(IntPtr hProcess, IntPtr Address, array<System::Byte>^% lpBuffer, UInt32 nSize);

Overlay: (not recommended to be used in general, manipulation of the transparent renderer display window)

	static void MakeClickable(bool canclick);
	static bool IsOnTop();

ImGui: (currently used only by the SDK for the menu)

  static bool Begin( String^ displayName, bool% active, ImGuiWindowFlags flags );
  static bool Begin( String^ displayName, ImGuiWindowFlags flags );

  static void End();

  static bool IsWindowCollapsed();
  static bool IsWindowFocused( ImGuiFocusedFlags flags );
  static bool IsWindowHovered( ImGuiHoveredFlags flags );

  static void SetNextWindowPos( Vector2 pos, ImGuiCond cond );
  static void SetNextWindowSize( Vector2 size, ImGuiCond cond );
  static void SetNextWindowSizeConstraints(Vector2 minSize, Vector2 maxSize);

  static void PushStyleColor(ImGuiCol type, Color color);
  static void PopStyleColor();
  static void PushItemWidth(float width);
  static float GetWindowWidth();
  static float GetWindowContentRegionWidth();

  static void Separator();
  static void SameLine( float posX, float spacingW );
  static void NewLine();

  static void Text( String^ text );
  static void TextColored( Color color, String^ text );
  static void TextWrapped( String^ text );
  static void LabelText( String^ label, String^ text );
  static void BulletText( String^ text );

  static bool Button( String^ label, Vector2 size );
  static bool SmallButton( String^ label );
  static bool Checkbox( String^ label, bool% val );
  static bool RadioButton( String^ label, bool active );
  static void Bullet();

  static bool BeginCombo( String^ label, String^ previewValue, ImGuiComboFlags flags );
  static bool Combo( String^ name, int %currentItem, array< String^ >^ items );
  static void EndCombo();

  static bool SliderFloat( String^ label, float% val, float min, float max );
  static bool SliderInt( String^ name, int% val, int min, int max );

  static bool InputFloat( String^ label, float% val );
  static bool InputInt( String^ label, int% val );

  static bool ColorPicker4( String^ label, array< float >^ values, ImGuiColorEditFlags flags );
  static bool ColorPicker3( String^ label, array< float >^ values, ImGuiColorEditFlags flags );
  static bool ColorEdit4( String^ label, array< float >^ values, ImGuiColorEditFlags flags );
  static bool ColorEdit3( String^ label, array< float >^ values, ImGuiColorEditFlags flags );

  static bool TreeNode( String^ name, String^ uniqueID );
  static bool TreeNode( String^ name );
  static void TreePop();
  static bool CollapsingHeader( String^ label, ImGuiTreeNodeFlags flags );
  static void SetNextTreeNodeOpen( bool open, ImGuiCond cond );

  static bool ListBox( String^ label, int% currentItem, array< String^ >^ items );

  static bool BeginMainMenuBar();
  static void EndMainMenuBar();
  static bool BeginMenuBar();
  static void EndMenuBar();
  static bool BeginMenu( String^ displayName );
  static void EndMenu();
  static bool MenuItem( String^ displayName, String^ shortcut, bool selected, bool enabled );

  static void BeginTooltip();
  static void EndTooltip();
  static void SetTooltip( String^ text );

  static bool IsItemHovered( ImGuiHoveredFlags flags );
  static bool IsItemActive();
  static bool IsItemFocused();
  static bool IsItemClicked( int mouseButton );
  static bool IsItemVisible();
  static bool IsItemEdited();

  static void ShowHelpMarker( String^ text );
  static void TextWithColors( String^ format );

  static void PushID( String^ id );
  static void PopID();

  static void SetStyleColor( ImGuiCol index, Color color );
  static void SetStyleAlpha( float alpha );

  static bool BeginTabBar( String^ id, ImGuiTabBarFlags flags );
  static void EndTabBar();
  static bool BeginTabItem( String^ label, bool %open, ImGuiTabItemFlags flags );
  static void EndTabItem();
  static void SetTabItemClosed( String^ tabOrDockedWindowLabel );

  static void SetColor( ImGuiCol item, Color color );

Enums:

	public enum class TextAlignment {
		lefted, centered, righted
	};

	public enum class DriverName {
		Fairplay = 1,
	};

	public enum class BoxStance {
		standing, crouching, prone
	};

	public enum class W2SType {
		TypeOGL, TypeD3D, TypeCustom1
	};

	public enum class WindowMessage {
		WNULL = 0x0000,
		CREATE = 0x0001,
		DESTROY = 0x0002,
		MOVE = 0x0003,
		SIZE = 0x0005,
		ACTIVATE = 0x0006,
		SETFOCUS = 0x0007,
		KILLFOCUS = 0x0008,
		ENABLE = 0x000A,
		SETREDRAW = 0x000B,
		SETTEXT = 0x000C,
		GETTEXT = 0x000D,
		GETTEXTLENGTH = 0x000E,
		PAINT = 0x000F,
		CLOSE = 0x0010,
		QUERYENDSESSION = 0x0011,
		QUERYOPEN = 0x0013,
		ENDSESSION = 0x0016,
		QUIT = 0x0012,
		ERASEBKGND = 0x0014,
		SYSCOLORCHANGE = 0x0015,
		SHOWWINDOW = 0x0018,
		WININICHANGE = 0x001A,
		SETTINGCHANGE = WININICHANGE,
		DEVMODECHANGE = 0x001B,
		ACTIVATEAPP = 0x001C,
		FONTCHANGE = 0x001D,
		TIMECHANGE = 0x001E,
		CANCELMODE = 0x001F,
		SETCURSOR = 0x0020,
		MOUSEACTIVATE = 0x0021,
		CHILDACTIVATE = 0x0022,
		QUEUESYNC = 0x0023,
		GETMINMAXINFO = 0x0024,
		PAINTICON = 0x0026,
		ICONERASEBKGND = 0x0027,
		NEXTDLGCTL = 0x0028,
		SPOOLERSTATUS = 0x002A,
		DRAWITEM = 0x002B,
		MEASUREITEM = 0x002C,
		DELETEITEM = 0x002D,
		VKEYTOITEM = 0x002E,
		CHARTOITEM = 0x002F,
		SETFONT = 0x0030,
		GETFONT = 0x0031,
		SETHOTKEY = 0x0032,
		GETHOTKEY = 0x0033,
		QUERYDRAGICON = 0x0037,
		COMPAREITEM = 0x0039,
		GETOBJECT = 0x003D,
		COMPACTING = 0x0041,
		COMMNOTIFY = 0x0044,
		WINDOWPOSCHANGING = 0x0046,
		WINDOWPOSCHANGED = 0x0047,
		POWER = 0x0048,
		COPYDATA = 0x004A,
		CANCELJOURNAL = 0x004B,
		NOTIFY = 0x004E,
		INPUTLANGCHANGEREQUEST = 0x0050,
		INPUTLANGCHANGE = 0x0051,
		TCARD = 0x0052,
		HELP = 0x0053,
		USERCHANGED = 0x0054,
		NOTIFYFORMAT = 0x0055,
		CONTEXTMENU = 0x007B,
		STYLECHANGING = 0x007C,
		STYLECHANGED = 0x007D,
		DISPLAYCHANGE = 0x007E,
		GETICON = 0x007F,
		SETICON = 0x0080,
		NCCREATE = 0x0081,
		NCDESTROY = 0x0082,
		NCCALCSIZE = 0x0083,
		NCHITTEST = 0x0084,
		NCPAINT = 0x0085,
		NCACTIVATE = 0x0086,
		GETDLGCODE = 0x0087,
		SYNCPAINT = 0x0088,


		NCMOUSEMOVE = 0x00A0,
		NCLBUTTONDOWN = 0x00A1,
		NCLBUTTONUP = 0x00A2,
		NCLBUTTONDBLCLK = 0x00A3,
		NCRBUTTONDOWN = 0x00A4,
		NCRBUTTONUP = 0x00A5,
		NCRBUTTONDBLCLK = 0x00A6,
		NCMBUTTONDOWN = 0x00A7,
		NCMBUTTONUP = 0x00A8,
		NCMBUTTONDBLCLK = 0x00A9,
		NCXBUTTONDOWN = 0x00AB,
		NCXBUTTONUP = 0x00AC,
		NCXBUTTONDBLCLK = 0x00AD,

		INPUT_DEVICE_CHANGE = 0x00FE,
		INPUT = 0x00FF,

		KEYFIRST = 0x0100,
		KEYDOWN = 0x0100,
		KEYUP = 0x0101,
		CHAR = 0x0102,
		DEADCHAR = 0x0103,
		SYSKEYDOWN = 0x0104,
		SYSKEYUP = 0x0105,
		SYSCHAR = 0x0106,
		SYSDEADCHAR = 0x0107,
		UNICHAR = 0x0109,
		KEYLAST = 0x0109,

		IME_STARTCOMPOSITION = 0x010D,
		IME_ENDCOMPOSITION = 0x010E,
		IME_COMPOSITION = 0x010F,
		IME_KEYLAST = 0x010F,

		INITDIALOG = 0x0110,
		COMMAND = 0x0111,
		SYSCOMMAND = 0x0112,
		TIMER = 0x0113,
		HSCROLL = 0x0114,
		VSCROLL = 0x0115,
		INITMENU = 0x0116,
		INITMENUPOPUP = 0x0117,
		MENUSELECT = 0x011F,
		MENUCHAR = 0x0120,
		ENTERIDLE = 0x0121,
		MENURBUTTONUP = 0x0122,
		MENUDRAG = 0x0123,
		MENUGETOBJECT = 0x0124,
		UNINITMENUPOPUP = 0x0125,
		MENUCOMMAND = 0x0126,

		CHANGEUISTATE = 0x0127,
		UPDATEUISTATE = 0x0128,
		QUERYUISTATE = 0x0129,

		CTLCOLORMSGBOX = 0x0132,
		CTLCOLOREDIT = 0x0133,
		CTLCOLORLISTBOX = 0x0134,
		CTLCOLORBTN = 0x0135,
		CTLCOLORDLG = 0x0136,
		CTLCOLORSCROLLBAR = 0x0137,
		CTLCOLORSTATIC = 0x0138,
		GETHMENU = 0x01E1,

		MOUSEFIRST = 0x0200,
		MOUSEMOVE = 0x0200,
		LBUTTONDOWN = 0x0201,
		LBUTTONUP = 0x0202,
		LBUTTONDBLCLK = 0x0203,
		RBUTTONDOWN = 0x0204,
		RBUTTONUP = 0x0205,
		RBUTTONDBLCLK = 0x0206,
		MBUTTONDOWN = 0x0207,
		MBUTTONUP = 0x0208,
		MBUTTONDBLCLK = 0x0209,
		MOUSEWHEEL = 0x020A,
		XBUTTONDOWN = 0x020B,
		XBUTTONUP = 0x020C,
		XBUTTONDBLCLK = 0x020D,
		MOUSEHWHEEL = 0x020E,

		PARENTNOTIFY = 0x0210,
		ENTERMENULOOP = 0x0211,
		EXITMENULOOP = 0x0212,

		NEXTMENU = 0x0213,
		SIZING = 0x0214,
		CAPTURECHANGED = 0x0215,
		MOVING = 0x0216,

		POWERBROADCAST = 0x0218,

		DEVICECHANGE = 0x0219,

		MDICREATE = 0x0220,
		MDIDESTROY = 0x0221,
		MDIACTIVATE = 0x0222,
		MDIRESTORE = 0x0223,
		MDINEXT = 0x0224,
		MDIMAXIMIZE = 0x0225,
		MDITILE = 0x0226,
		MDICASCADE = 0x0227,
		MDIICONARRANGE = 0x0228,
		MDIGETACTIVE = 0x0229,


		MDISETMENU = 0x0230,
		ENTERSIZEMOVE = 0x0231,
		EXITSIZEMOVE = 0x0232,
		DROPFILES = 0x0233,
		MDIREFRESHMENU = 0x0234,

		IME_SETCONTEXT = 0x0281,
		IME_NOTIFY = 0x0282,
		IME_CONTROL = 0x0283,
		IME_COMPOSITIONFULL = 0x0284,
		IME_SELECT = 0x0285,
		IME_CHAR = 0x0286,
		IME_REQUEST = 0x0288,
		IME_KEYDOWN = 0x0290,
		IME_KEYUP = 0x0291,

		MOUSEHOVER = 0x02A1,
		MOUSELEAVE = 0x02A3,
		NCMOUSEHOVER = 0x02A0,
		NCMOUSELEAVE = 0x02A2,

		WTSSESSION_CHANGE = 0x02B1,

		TABLET_FIRST = 0x02c0,
		TABLET_LAST = 0x02df,

		CUT = 0x0300,
		COPY = 0x0301,
		PASTE = 0x0302,
		CLEAR = 0x0303,
		UNDO = 0x0304,
		RENDERFORMAT = 0x0305,
		RENDERALLFORMATS = 0x0306,
		DESTROYCLIPBOARD = 0x0307,
		DRAWCLIPBOARD = 0x0308,
		PAINTCLIPBOARD = 0x0309,
		VSCROLLCLIPBOARD = 0x030A,
		SIZECLIPBOARD = 0x030B,
		ASKCBFORMATNAME = 0x030C,
		CHANGECBCHAIN = 0x030D,
		HSCROLLCLIPBOARD = 0x030E,
		QUERYNEWPALETTE = 0x030F,
		PALETTEISCHANGING = 0x0310,
		PALETTECHANGED = 0x0311,
		HOTKEY = 0x0312,

		PRINT = 0x0317,
		PRINTCLIENT = 0x0318,

		APPCOMMAND = 0x0319,

		THEMECHANGED = 0x031A,

		CLIPBOARDUPDATE = 0x031D,

		DWMCOMPOSITIONCHANGED = 0x031E,
		DWMNCRENDERINGCHANGED = 0x031F,
		DWMCOLORIZATIONCOLORCHANGED = 0x0320,
		DWMWINDOWMAXIMIZEDCHANGE = 0x0321,

		GETTITLEBARINFOEX = 0x033F,

		HANDHELDFIRST = 0x0358,
		HANDHELDLAST = 0x035F,

		AFXFIRST = 0x0360,
		AFXLAST = 0x037F,

		PENWINFIRST = 0x0380,
		PENWINLAST = 0x038F,

		APP = 0x8000,

		USER = 0x0400,

		REFLECT = USER + 0x1C00,
	};

	public enum class KEYEVENTF {
		KEYDOWN = 0x0,
		EXTENDEDKEY = 0x1,
		KEYUP = 0x2,
	};

	public enum class MouseEventFlags {
		LEFTDOWN = 0x00000002,
		LEFTUP = 0x00000004,
		MIDDLEDOWN = 0x00000020,
		MIDDLEUP = 0x00000040,
		MOVE = 0x00000001,
		ABSOLUTE_ = 0x00008000,
		RIGHTDOWN = 0x00000008,
		RIGHTUP = 0x00000010,
		WHEEL = 0x00000800,
		XDOWN = 0x00000080,
		XUP = 0x00000100,
	};

	public enum class MouseEventDataXButtons {
		NONE = 0x00000000,
		XBUTTON1_ = 0x00000001,
		XBUTTON2_ = 0x00000002,
	};

	public enum class VirtualKeyCode {
		LeftMouse = 0x01,
		RightMouse = 0x02,
		Cancel = 0x03,
		MiddleMouse = 0x04,
		MouseXB1 = 0x05,
		MouseXB2 = 0x06,
		Backspace = 0x08,
		Tab = 0x09,
		Clear = 0x0C,
		Enter = 0x0D,
		Shift = 0x10,
		Control = 0x11,
		Alt = 0x12,
		Pause = 0x13,
		CapsLock = 0x14,
		Escape = 0x1B,
		Space = 0x20,
		PageUp = 0x21,
		PageDown = 0x22,
		End = 0x23,
		Home = 0x24,
		Left = 0x25,
		Up = 0x26,
		Right = 0x27,
		Down = 0x28,
		Select = 0x29,
		Print = 0x2A,
		Execute = 0x2B,
		PrintScreen = 0x2C,
		Insert = 0x2D,
		Delete = 0x2E,
		Help = 0x2F,
		Zero = 0x30,
		One = 0x31,
		Two = 0x32,
		Three = 0x33,
		Four = 0x34,
		Five = 0x35,
		Six = 0x36,
		Seven = 0x37,
		Eight = 0x38,
		Nine = 0x39,
		A = 0x41,
		B = 0x42,
		C = 0x43,
		D = 0x44,
		E = 0x45,
		F = 0x46,
		G = 0x47,
		H = 0x48,
		I = 0x49,
		J = 0x4A,
		K = 0x4B,
		L = 0x4C,
		M = 0x4D,
		N = 0x4E,
		O = 0x4F,
		P = 0x50,
		Q = 0x51,
		R = 0x52,
		S = 0x53,
		T = 0x54,
		U = 0x55,
		V = 0x56,
		W = 0x57,
		X = 0x58,
		Y = 0x59,
		Z = 0x5A,
		LeftWindowsKey = 0x5B,
		RightWindowsKey = 0x5C,
		ApplicationsKey = 0x5D,
		Sleep = 0x5F,
		NumPad0 = 0x60,
		NumPad1 = 0x61,
		NumPad2 = 0x62,
		NumPad3 = 0x63,
		NumPad4 = 0x64,
		NumPad5 = 0x65,
		NumPad6 = 0x66,
		NumPad7 = 0x67,
		NumPad8 = 0x68,
		NumPad9 = 0x69,
		Multiply = 0x6A,
		Add = 0x6B,
		Seperator = 0x6C,
		Subtract = 0x6D,
		Decimal = 0x6E,
		Divide = 0x6F,
		F1 = 0x70,
		F2 = 0x71,
		F3 = 0x72,
		F4 = 0x73,
		F5 = 0x74,
		F6 = 0x75,
		F7 = 0x76,
		F8 = 0x77,
		F9 = 0x78,
		F10 = 0x79,
		F11 = 0x7A,
		F12 = 0x7B,
		F13 = 0x7C,
		F14 = 0x7D,
		F15 = 0x7E,
		F16 = 0x7F,
		F17 = 0x80,
		F18 = 0x81,
		F19 = 0x82,
		F20 = 0x83,
		F21 = 0x84,
		F22 = 0x85,
		F23 = 0x86,
		F24 = 0x87,
		Numlock = 0x90,
		ScrollLock = 0x91,
		LeftShift = 0xA0,
		RightShift = 0xA1,
		LeftControl = 0xA2,
		RightContol = 0xA3,
		LeftMenu = 0xA4,
		RightMenu = 0xA5,
		BrowserBack = 0xA6,
		BrowserForward = 0xA7,
		BrowserRefresh = 0xA8,
		BrowserStop = 0xA9,
		BrowserSearch = 0xAA,
		BrowserFavorites = 0xAB,
		BrowserHome = 0xAC,
		VolumeMute = 0xAD,
		VolumeDown = 0xAE,
		VolumeUp = 0xAF,
		NextTrack = 0xB0,
		PreviousTrack = 0xB1,
		StopMedia = 0xB2,
		PlayPause = 0xB3,
		LaunchMail = 0xB4,
		SelectMedia = 0xB5,
		LaunchApp1 = 0xB6,
		LaunchApp2 = 0xB7,
		OEM1 = 0xBA,
		OEMEqual = 0xBB,
		OEMPlus = 0xB8,
		OEMComma = 0xBC,
		OEMMinus = 0xBD,
		OEMPeriod = 0xBE,
		OEM2 = 0xBF,
		OEM3 = 0xC0,
		OEM4 = 0xDB,
		OEM5 = 0xDC,
		OEM6 = 0xDD,
		OEM7 = 0xDE,
		OEM8 = 0xDF,
		OEM102 = 0xE2,
		Process = 0xE5,
		Packet = 0xE7,
		Attn = 0xF6,
		CrSel = 0xF7,
		ExSel = 0xF8,
		EraseEOF = 0xF9,
		Play = 0xFA,
		Zoom = 0xFB,
		PA1 = 0xFD,
		OEMClear = 0xFE,
    None = 0x0
	};



  [Flags]
  public enum class ImGuiWindowFlags {
    None = 0,
    NoTitleBar = 1 << 0,   // Disable title-bar
    NoResize = 1 << 1,   // Disable user resizing with the lower-right grip
    NoMove = 1 << 2,   // Disable user moving the window
    NoScrollbar = 1 << 3,   // Disable scrollbars (window can still scroll with mouse or programatically)
    NoScrollWithMouse = 1 << 4,   // Disable user vertically scrolling with mouse wheel. On child window, mouse wheel will be forwarded to the parent unless NoScrollbar is also set.
    NoCollapse = 1 << 5,   // Disable user collapsing window by double-clicking on it
    AlwaysAutoResize = 1 << 6,   // Resize every window to its content every frame
    NoBackground = 1 << 7,   // Disable drawing background color (WindowBg, etc.) and outside border. Similar as using SetNextWindowBgAlpha(0.0f).
    NoSavedSettings = 1 << 8,   // Never load/save settings in .ini file
    NoMouseInputs = 1 << 9,   // Disable catching mouse, hovering test with pass through.
    MenuBar = 1 << 10,  // Has a menu-bar
    HorizontalScrollbar = 1 << 11,  // Allow horizontal scrollbar to appear (off by default). You may use SetNextWindowContentSize(ImVec2(width,0.0f)); prior to calling Begin() to specify width. Read code in imgui_demo in the "Horizontal Scrolling" section.
    NoFocusOnAppearing = 1 << 12,  // Disable taking focus when transitioning from hidden to visible state
    NoBringToFrontOnFocus = 1 << 13,  // Disable bringing window to front when taking focus (e.g. clicking on it or programatically giving it focus)
    AlwaysVerticalScrollbar = 1 << 14,  // Always show vertical scrollbar (even if ContentSize.y < Size.y)
    AlwaysHorizontalScrollbar = 1 << 15,  // Always show horizontal scrollbar (even if ContentSize.x < Size.x)
    AlwaysUseWindowPadding = 1 << 16,  // Ensure child windows without border uses style.WindowPadding (ignored by default for non-bordered child windows, because more convenient)
    NoNavInputs = 1 << 18,  // No gamepad/keyboard navigation within the window
    NoNavFocus = 1 << 19,  // No focusing toward this window with gamepad/keyboard navigation (e.g. skipped by CTRL+TAB)
    UnsavedDocument = 1 << 20,  // Append '*' to title without affecting the ID, as a convenience to avoid using the ### operator. When used in a tab/docking context, tab is selected on closure and closure is deferred by one frame to allow code to cancel the closure (with a confirmation popup, etc.) without flicker.
    NoDocking = 1 << 21,  // Disable docking of this window

    NoNav = NoNavInputs | NoNavFocus,
    NoDecoration = NoTitleBar | NoResize | NoScrollbar | NoCollapse,
    NoInputs = NoMouseInputs | NoNavInputs | NoNavFocus,

    
    NavFlattened = 1 << 23,  // [BETA] Allow gamepad/keyboard navigation to cross over parent border to this child (only use on child that have no scrolling!)
    ChildWindow = 1 << 24,  // Don't use! For internal use by BeginChild()
    Tooltip = 1 << 25,  // Don't use! For internal use by BeginTooltip()
    Popup = 1 << 26,  // Don't use! For internal use by BeginPopup()
    Modal = 1 << 27,  // Don't use! For internal use by BeginPopupModal()
    ChildMenu = 1 << 28,  // Don't use! For internal use by BeginMenu()
    DockNodeHost = 1 << 29   // Don't use! For internal use by Begin()/NewFrame()


    // [Obsolete]
    //ImGuiWindowFlags_ShowBorders          = 1 << 7,   // --> Set style.FrameBorderSize=1.0f / style.WindowBorderSize=1.0f to enable borders around windows and items
    //ImGuiWindowFlags_ResizeFromAnySide    = 1 << 17,  // --> Set io.ConfigWindowsResizeFromEdges and make sure mouse cursors are supported by back-end (io.BackendFlags & ImGuiBackendFlags_HasMouseCursors)
  };

  // Flags for ImGui::InputText()
  [Flags]
  public enum class ImGuiInputTextFlags {
    None = 0,
    CharsDecimal = 1 << 0,   // Allow 0123456789.+-*/
    CharsHexadecimal = 1 << 1,   // Allow 0123456789ABCDEFabcdef
    CharsUppercase = 1 << 2,   // Turn a..z into A..Z
    CharsNoBlank = 1 << 3,   // Filter out spaces, tabs
    AutoSelectAll = 1 << 4,   // Select entire text when first taking mouse focus
    EnterReturnsTrue = 1 << 5,   // Return 'true' when Enter is pressed (as opposed to when the value was modified)
    CallbackCompletion = 1 << 6,   // Callback on pressing TAB (for completion handling)
    CallbackHistory = 1 << 7,   // Callback on pressing Up/Down arrows (for history handling)
    CallbackAlways = 1 << 8,   // Callback on each iteration. User code may query cursor position, modify text buffer.
    CallbackCharFilter = 1 << 9,   // Callback on character inputs to replace or discard them. Modify 'EventChar' to replace or discard, or return 1 in callback to discard.
    AllowTabInput = 1 << 10,  // Pressing TAB input a '\t' character into the text field
    CtrlEnterForNewLine = 1 << 11,  // In multi-line mode, unfocus with Enter, add new line with Ctrl+Enter (default is opposite: unfocus with Ctrl+Enter, add line with Enter).
    NoHorizontalScroll = 1 << 12,  // Disable following the cursor horizontally
    AlwaysInsertMode = 1 << 13,  // Insert mode
    ReadOnly = 1 << 14,  // Read-only mode
    Password = 1 << 15,  // Password mode, display all characters as '*'
    NoUndoRedo = 1 << 16,  // Disable undo/redo. Note that input text owns the text data while active, if you want to provide your own undo/redo stack you need e.g. to call ClearActiveID().
    CharsScientific = 1 << 17,  // Allow 0123456789.+-*/eE (Scientific notation input)
    CallbackResize = 1 << 18,  // Callback on buffer capacity changes request (beyond 'buf_size' parameter value), allowing the string to grow. Notify when the string wants to be resized (for string types which hold a cache of their Size). You will be provided a new BufSize in the callback and NEED to honor it. (see misc/cpp/imgui_stdlib.h for an example of using this)
    // [Internal]
    Multiline = 1 << 20   // For internal use by InputTextMultiline()
  };

  // Flags for ImGui::TreeNodeEx(), ImGui::CollapsingHeader*()
  [Flags]
  public enum class ImGuiTreeNodeFlags {
    None = 0,
    Selected = 1 << 0,   // Draw as selected
    Framed = 1 << 1,   // Full colored frame (e.g. for CollapsingHeader)
    AllowItemOverlap = 1 << 2,   // Hit testing to allow subsequent widgets to overlap this one
    NoTreePushOnOpen = 1 << 3,   // Don't do a TreePush() when open (e.g. for CollapsingHeader) = no extra indent nor pushing on ID stack
    NoAutoOpenOnLog = 1 << 4,   // Don't automatically and temporarily open node when Logging is active (by default logging will automatically open tree nodes)
    DefaultOpen = 1 << 5,   // Default node to be open
    OpenOnDoubleClick = 1 << 6,   // Need double-click to open node
    OpenOnArrow = 1 << 7,   // Only open when clicking on the arrow part. If ImGuiTreeNodeFlags_OpenOnDoubleClick is also set, single-click arrow or double-click all box to open.
    Leaf = 1 << 8,   // No collapsing, no arrow (use as a convenience for leaf nodes).
    Bullet = 1 << 9,   // Display a bullet instead of arrow
    FramePadding = 1 << 10,  // Use FramePadding (even for an unframed text node) to vertically align text baseline to regular widget height. Equivalent to calling AlignTextToFramePadding().
    //ImGuITreeNodeFlags_SpanAllAvailWidth  = 1 << 11,  // FIXME: TODO: Extend hit box horizontally even if not framed
    //ImGuiTreeNodeFlags_NoScrollOnOpen     = 1 << 12,  // FIXME: TODO: Disable automatic scroll on TreePop() if node got just open and contents is not visible
    NavLeftJumpsBackHere = 1 << 13,  // (WIP) Nav: left direction may move to this TreeNode() from any of its child (items submitted between TreeNode and TreePop)
    CollapsingHeader = Framed | NoTreePushOnOpen | NoAutoOpenOnLog
  };

  // Flags for ImGui::Selectable()
  [Flags]
  public enum class ImGuiSelectableFlags {
    None = 0,
    DontClosePopups = 1 << 0,   // Clicking this don't close parent popup window
    SpanAllColumns = 1 << 1,   // Selectable frame can span all columns (text will still fit in current column)
    AllowDoubleClick = 1 << 2,   // Generate press events on double clicks too
    Disabled = 1 << 3    // Cannot be selected, display greyed out text
  };

  // Flags for ImGui::BeginCombo()
  [Flags]
  public enum class ImGuiComboFlags {
    None = 0,
    PopupAlignLeft = 1 << 0,   // Align the popup toward the left by default
    HeightSmall = 1 << 1,   // Max ~4 items visible. Tip: If you want your combo popup to be a specific size you can use SetNextWindowSizeConstraints() prior to calling BeginCombo()
    HeightRegular = 1 << 2,   // Max ~8 items visible (default)
    HeightLarge = 1 << 3,   // Max ~20 items visible
    HeightLargest = 1 << 4,   // As many fitting items as possible
    NoArrowButton = 1 << 5,   // Display on the preview box without the square arrow button
    NoPreview = 1 << 6,   // Display only a square arrow button
  };

  // Flags for ImGui::BeginTabBar()
  [Flags]
  public enum class ImGuiTabBarFlags {
    None = 0,
    Reorderable = 1 << 0,   // Allow manually dragging tabs to re-order them + New tabs are appended at the end of list
    AutoSelectNewTabs = 1 << 1,   // Automatically select new tabs when they appear
    NoCloseWithMiddleMouseButton = 1 << 2,   // Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You can still repro this behavior on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false.
    NoTabListPopupButton = 1 << 3,
    NoTabListScrollingButtons = 1 << 4,
    FittingPolicyResizeDown = 1 << 5,   // Resize tabs when they don't fit
    FittingPolicyScroll = 1 << 6,   // Add scroll buttons when tabs don't fit
  };

  // Flags for ImGui::BeginTabItem()
  [Flags]
  public enum class ImGuiTabItemFlags {
    None = 0,
    UnsavedDocument = 1 << 0,   // Append '*' to title without affecting the ID, as a convenience to avoid using the ### operator. Also: tab is selected on closure and closure is deferred by one frame to allow code to undo it without flicker.
    SetSelected = 1 << 1,   // Trigger flag to programatically make the tab selected when calling BeginTabItem()
    NoCloseWithMiddleMouseButton = 1 << 2,   // Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You can still repro this behavior on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false.
    NoPushId = 1 << 3    // Don't call PushID(tab->ID)/PopID() on BeginTabItem()/EndTabItem()
  };

  // Flags for ImGui::IsWindowFocused()
  [Flags]
  public enum class ImGuiFocusedFlags {
    None = 0,
    ChildWindows = 1 << 0,   // IsWindowFocused(): Return true if any children of the window is focused
    RootWindow = 1 << 1,   // IsWindowFocused(): Test from root window (top most parent of the current hierarchy)
    AnyWindow = 1 << 2,   // IsWindowFocused(): Return true if any window is focused. Important: If you are trying to tell how to dispatch your low-level inputs, do NOT use this. Use ImGui::GetIO().WantCaptureMouse instead.
    RootAndChildWindows = RootWindow | ChildWindows
  };

  // Flags for ImGui::IsItemHovered(), ImGui::IsWindowHovered()
  // Note: if you are trying to check whether your mouse should be dispatched to imgui or to your app, you should use the 'io.WantCaptureMouse' boolean for that. Please read the FAQ!
  // Note: windows with the ImGuiWindowFlags_NoInputs flag are ignored by IsWindowHovered() calls.
  [Flags]
  public enum class ImGuiHoveredFlags {
    None = 0,        // Return true if directly over the item/window, not obstructed by another window, not obstructed by an active popup or modal blocking inputs under them.
    ChildWindows = 1 << 0,   // IsWindowHovered() only: Return true if any children of the window is hovered
    RootWindow = 1 << 1,   // IsWindowHovered() only: Test from root window (top most parent of the current hierarchy)
    AnyWindow = 1 << 2,   // IsWindowHovered() only: Return true if any window is hovered
    AllowWhenBlockedByPopup = 1 << 3,   // Return true even if a popup window is normally blocking access to this item/window
    //ImGuiHoveredFlags_AllowWhenBlockedByModal     = 1 << 4,   // Return true even if a modal popup window is normally blocking access to this item/window. FIXME-TODO: Unavailable yet.
    AllowWhenBlockedByActiveItem = 1 << 5,   // Return true even if an active item is blocking access to this item/window. Useful for Drag and Drop patterns.
    AllowWhenOverlapped = 1 << 6,   // Return true even if the position is overlapped by another window
    AllowWhenDisabled = 1 << 7,   // Return true even if the item is disabled
    RectOnly = AllowWhenBlockedByPopup | AllowWhenBlockedByActiveItem | AllowWhenOverlapped,
    RootAndChildWindows = RootWindow | ChildWindows
  };

  // Flags for ImGui::BeginDragDropSource(), ImGui::AcceptDragDropPayload()
  [Flags]
  public enum class ImGuiDragDropFlags {
    None = 0,
    // BeginDragDropSource() flags
    SourceNoPreviewTooltip = 1 << 0,   // By default, a successful call to BeginDragDropSource opens a tooltip so you can display a preview or description of the source contents. This flag disable this behavior.
    SourceNoDisableHover = 1 << 1,   // By default, when dragging we clear data so that IsItemHovered() will return false, to avoid subsequent user code submitting tooltips. This flag disable this behavior so you can still call IsItemHovered() on the source item.
    SourceNoHoldToOpenOthers = 1 << 2,   // Disable the behavior that allows to open tree nodes and collapsing header by holding over them while dragging a source item.
    SourceAllowNullID = 1 << 3,   // Allow items such as Text(), Image() that have no unique identifier to be used as drag source, by manufacturing a temporary identifier based on their window-relative position. This is extremely unusual within the dear imgui ecosystem and so we made it explicit.
    SourceExtern = 1 << 4,   // External source (from outside of imgui), won't attempt to read current item/window info. Will always return true. Only one Extern source can be active simultaneously.
    SourceAutoExpirePayload = 1 << 5,   // Automatically expire the payload if the source cease to be submitted (otherwise payloads are persisting while being dragged)
    // AcceptDragDropPayload() flags
    AcceptBeforeDelivery = 1 << 10,  // AcceptDragDropPayload() will returns true even before the mouse button is released. You can then call IsDelivery() to test if the payload needs to be delivered.
    AcceptNoDrawDefaultRect = 1 << 11,  // Do not draw the default highlight rectangle when hovering over target.
    AcceptNoPreviewTooltip = 1 << 12,  // Request hiding the BeginDragDropSource tooltip from the BeginDragDropTarget site.
    AcceptPeekOnly = AcceptBeforeDelivery | AcceptNoDrawDefaultRect  // For peeking ahead and inspecting the payload before delivery.
  };

// A primary data type
  public enum class ImGuiDataType {
    S32,      // int
    U32,      // unsigned int
    S64,      // long long, __int64
    U64,      // unsigned long long, unsigned __int64
    Float,    // float
    Double,   // double
  };

  // A cardinal direction
  public enum class ImGuiDir {
    None = -1,
    Left = 0,
    Right = 1,
    Up = 2,
    Down = 3,
  };

  // User fill ImGuiIO.KeyMap[] array with indices into the ImGuiIO.KeysDown[512] array
  public enum class ImGuiKey {
    Tab,
    LeftArrow,
    RightArrow,
    UpArrow,
    DownArrow,
    PageUp,
    PageDown,
    Home,
    End,
    Insert,
    Delete,
    Backspace,
    Space,
    Enter,
    Escape,
    A,         // for text edit CTRL+A: select all
    C,         // for text edit CTRL+C: copy
    V,         // for text edit CTRL+V: paste
    X,         // for text edit CTRL+X: cut
    Y,         // for text edit CTRL+Y: redo
    Z,         // for text edit CTRL+Z: undo
  };


  // Enumeration for PushStyleColor() / PopStyleColor()
  public enum class ImGuiCol
  {
    Text,
    TextDisabled,
    WindowBg,              // Background of normal windows
    ChildBg,               // Background of child windows
    PopupBg,               // Background of popups, menus, tooltips windows
    Border,
    BorderShadow,
    FrameBg,               // Background of checkbox, radio button, plot, slider, text input
    FrameBgHovered,
    FrameBgActive,
    TitleBg,
    TitleBgActive,
    TitleBgCollapsed,
    MenuBarBg,
    ScrollbarBg,
    ScrollbarGrab,
    ScrollbarGrabHovered,
    ScrollbarGrabActive,
    CheckMark,
    SliderGrab,
    SliderGrabActive,
    Button,
    ButtonHovered,
    ButtonActive,
    Header,
    HeaderHovered,
    HeaderActive,
    Separator,
    SeparatorHovered,
    SeparatorActive,
    ResizeGrip,
    ResizeGripHovered,
    ResizeGripActive,
    Tab,
    TabHovered,
    TabActive,
    TabUnfocused,
    TabUnfocusedActive,
    DockingPreview,
    DockingEmptyBg,        // Background color for empty node (e.g. CentralNode with no window docked into it)
    PlotLines,
    PlotLinesHovered,
    PlotHistogram,
    PlotHistogramHovered,
    TextSelectedBg,
    DragDropTarget,
    NavHighlight,          // Gamepad/keyboard: current highlighted item
    NavWindowingHighlight, // Highlight window when using CTRL+TAB
    NavWindowingDimBg,     // Darken/colorize entire screen behind the CTRL+TAB window list, when active
    ModalWindowDimBg,      // Darken/colorize entire screen behind a modal window, when one is active
  };

  // Enumeration for PushStyleVar() / PopStyleVar() to temporarily modify the ImGuiStyle structure.
  // NB: the enum only refers to fields of ImGuiStyle which makes sense to be pushed/popped inside UI code. During initialization, feel free to just poke into ImGuiStyle directly.
  // NB: if changing this enum, you need to update the associated internal table GStyleVarInfo[] accordingly. This is where we link enum values to members offset/type.
  public enum class ImGuiStyleVar
  {
    // Enum name ......................// Member in ImGuiStyle structure (see ImGuiStyle for descriptions)
    Alpha,               // float     Alpha
    WindowPadding,       // ImVec2    WindowPadding
    WindowRounding,      // float     WindowRounding
    WindowBorderSize,    // float     WindowBorderSize
    WindowMinSize,       // ImVec2    WindowMinSize
    WindowTitleAlign,    // ImVec2    WindowTitleAlign
    ChildRounding,       // float     ChildRounding
    ChildBorderSize,     // float     ChildBorderSize
    PopupRounding,       // float     PopupRounding
    PopupBorderSize,     // float     PopupBorderSize
    FramePadding,        // ImVec2    FramePadding
    FrameRounding,       // float     FrameRounding
    FrameBorderSize,     // float     FrameBorderSize
    ItemSpacing,         // ImVec2    ItemSpacing
    ItemInnerSpacing,    // ImVec2    ItemInnerSpacing
    IndentSpacing,       // float     IndentSpacing
    ScrollbarSize,       // float     ScrollbarSize
    ScrollbarRounding,   // float     ScrollbarRounding
    GrabMinSize,         // float     GrabMinSize
    GrabRounding,        // float     GrabRounding
    TabRounding,         // float     TabRounding
    ButtonTextAlign,     // ImVec2    ButtonTextAlign
  };

  // Flags for ColorEdit3() / ColorEdit4() / ColorPicker3() / ColorPicker4() / ColorButton()
  [Flags]
  public enum class ImGuiColorEditFlags
  {
    None = 0,
    NoAlpha = 1 << 1,   //              // ColorEdit, ColorPicker, ColorButton: ignore Alpha component (read 3 components from the input pointer).
    NoPicker = 1 << 2,   //              // ColorEdit: disable picker when clicking on colored square.
    NoOptions = 1 << 3,   //              // ColorEdit: disable toggling options menu when right-clicking on inputs/small preview.
    NoSmallPreview = 1 << 4,   //              // ColorEdit, ColorPicker: disable colored square preview next to the inputs. (e.g. to show only the inputs)
    NoInputs = 1 << 5,   //              // ColorEdit, ColorPicker: disable inputs sliders/text widgets (e.g. to show only the small preview colored square).
    NoTooltip = 1 << 6,   //              // ColorEdit, ColorPicker, ColorButton: disable tooltip when hovering the preview.
    NoLabel = 1 << 7,   //              // ColorEdit, ColorPicker: disable display of inline text label (the label is still forwarded to the tooltip and picker).
    NoSidePreview = 1 << 8,   //              // ColorPicker: disable bigger color preview on right side of the picker, use small colored square preview instead.
    NoDragDrop = 1 << 9,   //              // ColorEdit: disable drag and drop target. ColorButton: disable drag and drop source.

    // User Options (right-click on widget to change some of them). You can set application defaults using SetColorEditOptions(). The idea is that you probably don't want to override them in most of your calls, let the user choose and/or call SetColorEditOptions() during startup.
    AlphaBar = 1 << 16,  //              // ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker.
    AlphaPreview = 1 << 17,  //              // ColorEdit, ColorPicker, ColorButton: display preview as a transparent color over a checkerboard, instead of opaque.
    AlphaPreviewHalf = 1 << 18,  //              // ColorEdit, ColorPicker, ColorButton: display half opaque / half checkerboard, instead of opaque.
    HDR = 1 << 19,  //              // (WIP) ColorEdit: Currently only disable 0.0f..1.0f limits in RGBA edition (note: you probably want to use ImGuiColorEditFlags_Float flag as well).
    RGB = 1 << 20,  // [Inputs]     // ColorEdit: choose one among RGB/HSV/HEX. ColorPicker: choose any combination using RGB/HSV/HEX.
    HSV = 1 << 21,  // [Inputs]     // "
    HEX = 1 << 22,  // [Inputs]     // "
    Uint8 = 1 << 23,  // [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0..255.
    Float = 1 << 24,  // [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0.0f..1.0f floats instead of 0..255 integers. No round-trip of value via integers.
    PickerHueBar = 1 << 25,  // [PickerMode] // ColorPicker: bar for Hue, rectangle for Sat/Value.
    PickerHueWheel = 1 << 26,  // [PickerMode] // ColorPicker: wheel for Hue, triangle for Sat/Value.
  };

  // Enumeration for GetMouseCursor()
  // User code may request binding to display given cursor by calling SetMouseCursor(), which is why we have some cursors that are marked unused here
  public enum class ImGuiMouseCursor
  {
    None = -1,
    Arrow = 0,
    TextInput,         // When hovering over InputText, etc.
    ResizeAll,         // (Unused by imgui functions)
    ResizeNS,          // When hovering over an horizontal border
    ResizeEW,          // When hovering over a vertical border or a column
    ResizeNESW,        // When hovering over the bottom-left corner of a window
    ResizeNWSE,        // When hovering over the bottom-right corner of a window
    Hand,              // (Unused by imgui functions. Use for e.g. hyperlinks)
  };

  // Enumateration for ImGui::SetWindow***(), SetNextWindow***(), SetNextTreeNode***() functions
  // Represent a condition.
  // Important: Treat as a regular enum! Do NOT combine multiple values using binary operators! All the functions above treat 0 as a shortcut to ImGuiCond_Always.
  [Flags]
  public enum class ImGuiCond
  {
    Always = 1 << 0,   // Set the variable
    Once = 1 << 1,   // Set the variable once per runtime session (only the first call with succeed)
    FirstUseEver = 1 << 2,   // Set the variable if the object/window has no persistently saved data (no entry in .ini file)
    Appearing = 1 << 3    // Set the variable if the object/window is appearing after being hidden/inactive (or the first time)
  };

  [Flags]
  public enum class ImGuiDockNodeFlags {
    None = 0,
    KeepAliveOnly = 1 << 0,   // Don't display the dockspace node but keep it alive. Windows docked into this dockspace node won't be undocked.
    NoSplit = 1 << 1,   // Disable splitting the node into smaller nodes. Useful e.g. when embedding dockspaces into a main root one (the root one may have splitting disabled to reduce confusion)
    // NoCentralNode              = 1 << 2,   // Disable Central Node (the node which can stay empty)
    NoDockingInCentralNode = 1 << 3,   // Disable docking inside the Central Node, which will be always kept empty.
    // NoLayoutChanges            = 1 << 4,   // Disable adding/removing nodes interactively. Useful with programatically setup dockspaces.
    NoResize = 1 << 5,   // Disable resizing child nodes using the splitter/separators. Useful with programatically setup dockspaces. 
    PassthruDockspace = 1 << 6    // 1) DockSpace() will render a ImGuiCol_WindowBg background covering everything excepted the Central Node when empty. Meaning the host window should probably use SetNextWindowBgAlpha(0.0f) prior to Begin() when using this. 2) When Central Node is empty: let inputs pass-through + won't display a DockingEmptyBg background.
  };

 


giphy.gif

Gaben strategies too OP.

Share this post


Link to post
Share on other sites

Last update on 13 May 2020:

-Added a safe version (without exec) of WriteProcessMemory in different variations for values/strings writing.
-Added keyboard and mouse input API's.


giphy.gif

Gaben strategies too OP.

Share this post


Link to post
Share on other sites

Update on 5 June 2020:

-Added new premium API allowing you to initialize a driver in order to read memory from games protected with BE/EAC/XIGNCODE3/FACEIT and so on...

  • Like 1

giphy.gif

Gaben strategies too OP.

Share this post


Link to post
Share on other sites
Guest
This topic is now closed to further replies.
Sign in to follow this  

×
×
  • Create New...