2020-10-12 23:34:22 +08:00
// dear imgui: Renderer + Platform Backend for Allegro 5
2018-06-09 01:37:33 +08:00
// (Info: Allegro 5 is a cross-platform general purpose library for handling windows, inputs, graphics, etc.)
2016-03-24 18:00:47 +08:00
2018-02-06 03:34:11 +08:00
// Implemented features:
2019-10-16 17:23:15 +08:00
// [X] Renderer: User texture binding. Use 'ALLEGRO_BITMAP*' as ImTextureID. Read the FAQ about ImTextureID!
2021-12-12 18:58:50 +08:00
// [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy ALLEGRO_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
2018-06-14 01:22:22 +08:00
// [X] Platform: Clipboard support (from Allegro 5.1.12)
2018-06-11 18:33:51 +08:00
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
// Issues:
2022-11-30 04:56:10 +08:00
// [ ] Renderer: The renderer is suboptimal as we need to convert vertices manually.
2018-09-20 16:37:55 +08:00
// [ ] Platform: Missing gamepad support.
2016-10-15 17:36:43 +08:00
2021-06-28 22:52:10 +08:00
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
2021-05-27 19:59:35 +08:00
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
2023-09-11 19:47:08 +08:00
// Learn about Dear ImGui:
// - FAQ https://dearimgui.com/faq
// - Getting Started https://dearimgui.com/getting-started
// - Documentation https://dearimgui.com/docs (same as your local docs/ folder).
// - Introduction, links and more at the top of imgui.cpp
2015-07-09 01:34:36 +08:00
2018-02-17 02:18:16 +08:00
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
2022-11-30 21:43:00 +08:00
// 2022-11-30: Renderer: Restoring using al_draw_indexed_prim() when Allegro version is >= 5.2.5.
2022-10-11 18:22:29 +08:00
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
2022-09-23 00:58:33 +08:00
// 2022-09-26: Inputs: Renamed ImGuiKey_ModXXX introduced in 1.87 to ImGuiMod_XXX (old names still supported).
// 2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago) with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
2022-01-18 00:22:37 +08:00
// 2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
2022-01-17 21:57:55 +08:00
// 2022-01-17: Inputs: always calling io.AddKeyModsEvent() next and before key event (not in NewFrame) to fix input queue with very low framerates.
2022-01-10 23:59:31 +08:00
// 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
2024-02-02 01:30:00 +08:00
// 2021-12-08: Renderer: Fixed mishandling of the ImDrawCmd::IdxOffset field! This is an old bug but it never had an effect until some internal rendering changes in 1.86.
2021-08-03 02:17:26 +08:00
// 2021-08-17: Calling io.AddFocusEvent() on ALLEGRO_EVENT_DISPLAY_SWITCH_OUT/ALLEGRO_EVENT_DISPLAY_SWITCH_IN events.
2021-06-28 22:52:10 +08:00
// 2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
2021-02-07 19:36:54 +08:00
// 2021-05-19: Renderer: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
2021-02-18 02:29:07 +08:00
// 2021-02-18: Change blending equation to preserve alpha in output buffer.
2020-08-10 21:31:48 +08:00
// 2020-08-10: Inputs: Fixed horizontal mouse wheel direction.
2019-12-05 22:43:05 +08:00
// 2019-12-05: Inputs: Added support for ImGuiMouseCursor_NotAllowed mouse cursor.
2019-07-22 09:39:50 +08:00
// 2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
2019-05-11 16:33:56 +08:00
// 2019-05-11: Inputs: Don't filter character value from ALLEGRO_EVENT_KEY_CHAR before calling AddInputCharacter().
2019-05-01 04:28:29 +08:00
// 2019-04-30: Renderer: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
2018-11-30 23:46:43 +08:00
// 2018-11-30: Platform: Added touchscreen support.
2018-12-01 01:18:15 +08:00
// 2018-11-30: Misc: Setting up io.BackendPlatformName/io.BackendRendererName so they can be displayed in the About Window.
2018-06-14 01:22:22 +08:00
// 2018-06-13: Platform: Added clipboard support (from Allegro 5.1.12).
// 2018-06-13: Renderer: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle.
2022-11-30 21:43:00 +08:00
// 2018-06-13: Renderer: Stopped using al_draw_indexed_prim() as it is buggy in Allegro's DX9 backend.
2018-06-14 01:22:22 +08:00
// 2018-06-13: Renderer: Backup/restore transform and clipping rectangle.
2018-06-11 18:33:51 +08:00
// 2018-06-11: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
2018-04-19 03:55:12 +08:00
// 2018-04-18: Misc: Renamed file from imgui_impl_a5.cpp to imgui_impl_allegro5.cpp.
2019-11-20 18:58:25 +08:00
// 2018-04-18: Misc: Added support for 32-bit vertex indices to avoid conversion at runtime. Added imconfig_allegro5.h to enforce 32-bit indices when included from imgui.h.
2018-06-09 01:37:33 +08:00
// 2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplAllegro5_RenderDrawData() in the .h file so you can call it yourself.
2018-02-17 02:18:16 +08:00
// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
// 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
2018-01-29 21:38:46 +08:00
# include "imgui.h"
2023-07-13 17:27:52 +08:00
# ifndef IMGUI_DISABLE
2018-04-19 03:55:12 +08:00
# include "imgui_impl_allegro5.h"
2023-07-13 17:27:52 +08:00
# include <stdint.h> // uint64_t
# include <cstring> // memcpy
2018-06-14 01:22:22 +08:00
// Allegro
2015-07-09 01:34:36 +08:00
# include <allegro5/allegro.h>
# include <allegro5/allegro_primitives.h>
# ifdef _WIN32
# include <allegro5/allegro_windows.h>
# endif
2022-11-30 21:43:00 +08:00
# define ALLEGRO_HAS_CLIPBOARD (ALLEGRO_VERSION_INT >= ((5 << 24) | (1 << 16) | (12 << 8))) // Clipboard only supported from Allegro 5.1.12
# define ALLEGRO_HAS_DRAW_INDEXED_PRIM (ALLEGRO_VERSION_INT >= ((5 << 24) | (2 << 16) | ( 5 << 8))) // DX9 implementation of al_draw_indexed_prim() got fixed in Allegro 5.2.5
2018-06-14 01:22:22 +08:00
// Visual Studio warnings
# ifdef _MSC_VER
# pragma warning (disable: 4127) // condition expression is constant
# endif
2015-07-09 01:34:36 +08:00
2022-11-30 21:43:00 +08:00
struct ImDrawVertAllegro
{
ImVec2 pos ;
ImVec2 uv ;
ALLEGRO_COLOR col ;
} ;
// FIXME-OPT: Unfortunately Allegro doesn't support 32-bit packed colors so we have to convert them to 4 float as well..
// FIXME-OPT: Consider inlining al_map_rgba()?
// see https://github.com/liballeg/allegro5/blob/master/src/pixels.c#L554
// and https://github.com/liballeg/allegro5/blob/master/include/allegro5/internal/aintern_pixels.h
# define DRAW_VERT_IMGUI_TO_ALLEGRO(DST, SRC) { (DST)->pos = (SRC)->pos; (DST)->uv = (SRC)->uv; unsigned char* c = (unsigned char*)&(SRC)->col; (DST)->col = al_map_rgba(c[0], c[1], c[2], c[3]); }
2021-06-28 22:52:10 +08:00
// Allegro Data
struct ImGui_ImplAllegro5_Data
{
ALLEGRO_DISPLAY * Display ;
ALLEGRO_BITMAP * Texture ;
double Time ;
ALLEGRO_MOUSE_CURSOR * MouseCursorInvisible ;
ALLEGRO_VERTEX_DECL * VertexDecl ;
char * ClipboardTextData ;
2022-11-30 21:43:00 +08:00
ImVector < ImDrawVertAllegro > BufVertices ;
ImVector < int > BufIndices ;
2022-03-13 14:15:32 +08:00
ImGui_ImplAllegro5_Data ( ) { memset ( ( void * ) this , 0 , sizeof ( * this ) ) ; }
2021-06-28 22:52:10 +08:00
} ;
2021-06-30 21:22:15 +08:00
// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
2022-10-11 18:22:29 +08:00
static ImGui_ImplAllegro5_Data * ImGui_ImplAllegro5_GetBackendData ( ) { return ImGui : : GetCurrentContext ( ) ? ( ImGui_ImplAllegro5_Data * ) ImGui : : GetIO ( ) . BackendPlatformUserData : nullptr ; }
2015-07-09 01:34:36 +08:00
2019-05-01 04:15:59 +08:00
static void ImGui_ImplAllegro5_SetupRenderState ( ImDrawData * draw_data )
2015-07-09 02:41:09 +08:00
{
2019-05-01 04:15:59 +08:00
// Setup blending
2021-02-18 02:29:07 +08:00
al_set_separate_blender ( ALLEGRO_ADD , ALLEGRO_ALPHA , ALLEGRO_INVERSE_ALPHA , ALLEGRO_ADD , ALLEGRO_ONE , ALLEGRO_INVERSE_ALPHA ) ;
2015-07-09 01:53:30 +08:00
2018-06-14 01:22:22 +08:00
// Setup orthographic projection matrix
2018-09-13 22:44:08 +08:00
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right).
2018-06-14 01:22:22 +08:00
{
float L = draw_data - > DisplayPos . x ;
float R = draw_data - > DisplayPos . x + draw_data - > DisplaySize . x ;
float T = draw_data - > DisplayPos . y ;
float B = draw_data - > DisplayPos . y + draw_data - > DisplaySize . y ;
ALLEGRO_TRANSFORM transform ;
al_identity_transform ( & transform ) ;
al_use_transform ( & transform ) ;
al_orthographic_transform ( & transform , L , T , 1.0f , R , B , - 1.0f ) ;
al_use_projection_transform ( & transform ) ;
}
2019-05-01 04:15:59 +08:00
}
// Render function.
void ImGui_ImplAllegro5_RenderDrawData ( ImDrawData * draw_data )
{
// Avoid rendering when minimized
if ( draw_data - > DisplaySize . x < = 0.0f | | draw_data - > DisplaySize . y < = 0.0f )
return ;
// Backup Allegro state that will be modified
2021-06-28 22:52:10 +08:00
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
2019-05-01 04:15:59 +08:00
ALLEGRO_TRANSFORM last_transform = * al_get_current_transform ( ) ;
ALLEGRO_TRANSFORM last_projection_transform = * al_get_current_projection_transform ( ) ;
int last_clip_x , last_clip_y , last_clip_w , last_clip_h ;
al_get_clipping_rectangle ( & last_clip_x , & last_clip_y , & last_clip_w , & last_clip_h ) ;
int last_blender_op , last_blender_src , last_blender_dst ;
al_get_blender ( & last_blender_op , & last_blender_src , & last_blender_dst ) ;
// Setup desired render state
ImGui_ImplAllegro5_SetupRenderState ( draw_data ) ;
2018-06-14 01:22:22 +08:00
2019-05-01 04:15:59 +08:00
// Render command lists
2016-03-26 22:43:45 +08:00
for ( int n = 0 ; n < draw_data - > CmdListsCount ; n + + )
2015-07-09 01:53:30 +08:00
{
2015-07-09 02:55:40 +08:00
const ImDrawList * cmd_list = draw_data - > CmdLists [ n ] ;
2015-07-09 02:41:09 +08:00
2022-11-30 21:43:00 +08:00
ImVector < ImDrawVertAllegro > & vertices = bd - > BufVertices ;
# if ALLEGRO_HAS_DRAW_INDEXED_PRIM
2022-11-30 04:56:10 +08:00
vertices . resize ( cmd_list - > VtxBuffer . Size ) ;
for ( int i = 0 ; i < cmd_list - > VtxBuffer . Size ; i + + )
2015-07-09 01:53:30 +08:00
{
2022-11-30 04:56:10 +08:00
const ImDrawVert * src_v = & cmd_list - > VtxBuffer [ i ] ;
2018-06-14 01:22:22 +08:00
ImDrawVertAllegro * dst_v = & vertices [ i ] ;
2022-11-30 21:43:00 +08:00
DRAW_VERT_IMGUI_TO_ALLEGRO ( dst_v , src_v ) ;
2015-07-09 01:53:30 +08:00
}
2022-10-11 18:22:29 +08:00
const int * indices = nullptr ;
2018-04-19 03:51:14 +08:00
if ( sizeof ( ImDrawIdx ) = = 2 )
{
2022-11-30 21:43:00 +08:00
// FIXME-OPT: Allegro doesn't support 16-bit indices.
// You can '#define ImDrawIdx int' in imconfig.h to request Dear ImGui to output 32-bit indices.
2018-04-19 03:51:14 +08:00
// Otherwise, we convert them from 16-bit to 32-bit at runtime here, which works perfectly but is a little wasteful.
2022-11-30 21:43:00 +08:00
bd - > BufIndices . resize ( cmd_list - > IdxBuffer . Size ) ;
2018-04-19 03:51:14 +08:00
for ( int i = 0 ; i < cmd_list - > IdxBuffer . Size ; + + i )
2022-11-30 21:43:00 +08:00
bd - > BufIndices [ i ] = ( int ) cmd_list - > IdxBuffer . Data [ i ] ;
indices = bd - > BufIndices . Data ;
2018-04-19 03:51:14 +08:00
}
else if ( sizeof ( ImDrawIdx ) = = 4 )
{
indices = ( const int * ) cmd_list - > IdxBuffer . Data ;
}
2022-11-30 21:43:00 +08:00
# else
// Allegro's implementation of al_draw_indexed_prim() for DX9 was broken until 5.2.5. Unindex buffers ourselves while converting vertex format.
vertices . resize ( cmd_list - > IdxBuffer . Size ) ;
for ( int i = 0 ; i < cmd_list - > IdxBuffer . Size ; i + + )
{
const ImDrawVert * src_v = & cmd_list - > VtxBuffer [ cmd_list - > IdxBuffer [ i ] ] ;
ImDrawVertAllegro * dst_v = & vertices [ i ] ;
DRAW_VERT_IMGUI_TO_ALLEGRO ( dst_v , src_v ) ;
}
# endif
2015-07-09 02:55:40 +08:00
2019-02-12 01:38:07 +08:00
// Render command lists
ImVec2 clip_off = draw_data - > DisplayPos ;
2016-09-04 01:24:57 +08:00
for ( int cmd_i = 0 ; cmd_i < cmd_list - > CmdBuffer . Size ; cmd_i + + )
2015-07-09 01:53:30 +08:00
{
2015-07-09 02:55:40 +08:00
const ImDrawCmd * pcmd = & cmd_list - > CmdBuffer [ cmd_i ] ;
2016-03-26 22:43:45 +08:00
if ( pcmd - > UserCallback )
2015-07-09 01:53:30 +08:00
{
2019-05-01 04:15:59 +08:00
// User callback, registered via ImDrawList::AddCallback()
// (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
if ( pcmd - > UserCallback = = ImDrawCallback_ResetRenderState )
ImGui_ImplAllegro5_SetupRenderState ( draw_data ) ;
else
pcmd - > UserCallback ( cmd_list , pcmd ) ;
2015-07-09 01:53:30 +08:00
}
2016-03-26 22:43:45 +08:00
else
2015-07-09 01:53:30 +08:00
{
2021-08-24 23:03:52 +08:00
// Project scissor/clipping rectangles into framebuffer space
ImVec2 clip_min ( pcmd - > ClipRect . x - clip_off . x , pcmd - > ClipRect . y - clip_off . y ) ;
ImVec2 clip_max ( pcmd - > ClipRect . z - clip_off . x , pcmd - > ClipRect . w - clip_off . y ) ;
2021-12-01 04:48:29 +08:00
if ( clip_max . x < = clip_min . x | | clip_max . y < = clip_min . y )
2021-08-24 23:03:52 +08:00
continue ;
// Apply scissor/clipping rectangle, Draw
2021-02-07 19:36:54 +08:00
ALLEGRO_BITMAP * texture = ( ALLEGRO_BITMAP * ) pcmd - > GetTexID ( ) ;
2021-08-31 03:36:01 +08:00
al_set_clipping_rectangle ( clip_min . x , clip_min . y , clip_max . x - clip_min . x , clip_max . y - clip_min . y ) ;
2022-11-30 21:43:00 +08:00
# if ALLEGRO_HAS_DRAW_INDEXED_PRIM
al_draw_indexed_prim ( & vertices [ 0 ] , bd - > VertexDecl , texture , & indices [ pcmd - > IdxOffset ] , pcmd - > ElemCount , ALLEGRO_PRIM_TRIANGLE_LIST ) ;
# else
al_draw_prim ( & vertices [ 0 ] , bd - > VertexDecl , texture , pcmd - > IdxOffset , pcmd - > IdxOffset + pcmd - > ElemCount , ALLEGRO_PRIM_TRIANGLE_LIST ) ;
# endif
2015-07-09 01:53:30 +08:00
}
}
2015-07-09 01:34:36 +08:00
}
2018-06-14 01:22:22 +08:00
// Restore modified Allegro state
al_set_blender ( last_blender_op , last_blender_src , last_blender_dst ) ;
al_set_clipping_rectangle ( last_clip_x , last_clip_y , last_clip_w , last_clip_h ) ;
al_use_transform ( & last_transform ) ;
al_use_projection_transform ( & last_projection_transform ) ;
2015-07-09 01:34:36 +08:00
}
2018-06-09 01:37:33 +08:00
bool ImGui_ImplAllegro5_CreateDeviceObjects ( )
2015-07-09 01:34:36 +08:00
{
2015-11-29 22:54:05 +08:00
// Build texture atlas
2021-06-28 22:52:10 +08:00
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
2020-06-30 21:31:54 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2019-03-29 23:17:04 +08:00
unsigned char * pixels ;
2015-07-09 01:53:30 +08:00
int width , height ;
io . Fonts - > GetTexDataAsRGBA32 ( & pixels , & width , & height ) ;
// Create texture
2022-04-07 20:28:08 +08:00
// (Bilinear sampling is required by default. Set 'io.Fonts->Flags |= ImFontAtlasFlags_NoBakedLines' or 'style.AntiAliasedLinesUseTex = false' to allow point/nearest sampling)
2015-07-09 01:53:30 +08:00
int flags = al_get_new_bitmap_flags ( ) ;
int fmt = al_get_new_bitmap_format ( ) ;
2020-06-30 21:31:54 +08:00
al_set_new_bitmap_flags ( ALLEGRO_MEMORY_BITMAP | ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR ) ;
2015-07-09 01:53:30 +08:00
al_set_new_bitmap_format ( ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE ) ;
ALLEGRO_BITMAP * img = al_create_bitmap ( width , height ) ;
al_set_new_bitmap_flags ( flags ) ;
al_set_new_bitmap_format ( fmt ) ;
2016-03-26 22:43:45 +08:00
if ( ! img )
2015-07-09 01:53:30 +08:00
return false ;
2020-06-30 21:31:54 +08:00
ALLEGRO_LOCKED_REGION * locked_img = al_lock_bitmap ( img , al_get_bitmap_format ( img ) , ALLEGRO_LOCK_WRITEONLY ) ;
2016-03-26 22:43:45 +08:00
if ( ! locked_img )
2015-07-09 01:53:30 +08:00
{
al_destroy_bitmap ( img ) ;
return false ;
}
2020-06-30 21:31:54 +08:00
memcpy ( locked_img - > data , pixels , sizeof ( int ) * width * height ) ;
2015-07-09 01:53:30 +08:00
al_unlock_bitmap ( img ) ;
// Convert software texture to hardware texture.
ALLEGRO_BITMAP * cloned_img = al_clone_bitmap ( img ) ;
2015-07-09 01:34:36 +08:00
al_destroy_bitmap ( img ) ;
2016-03-26 22:43:45 +08:00
if ( ! cloned_img )
2015-07-09 01:53:30 +08:00
return false ;
2015-07-09 01:34:36 +08:00
2015-07-09 01:53:30 +08:00
// Store our identifier
2022-05-04 21:00:41 +08:00
io . Fonts - > SetTexID ( ( ImTextureID ) ( intptr_t ) cloned_img ) ;
2021-06-28 22:52:10 +08:00
bd - > Texture = cloned_img ;
2015-07-09 01:34:36 +08:00
2015-07-09 02:16:50 +08:00
// Create an invisible mouse cursor
// Because al_hide_mouse_cursor() seems to mess up with the actual inputs..
2020-06-30 21:31:54 +08:00
ALLEGRO_BITMAP * mouse_cursor = al_create_bitmap ( 8 , 8 ) ;
2021-06-28 22:52:10 +08:00
bd - > MouseCursorInvisible = al_create_mouse_cursor ( mouse_cursor , 0 , 0 ) ;
2015-07-09 02:16:50 +08:00
al_destroy_bitmap ( mouse_cursor ) ;
2015-07-09 01:53:30 +08:00
return true ;
2015-07-09 01:34:36 +08:00
}
2018-06-09 01:37:33 +08:00
void ImGui_ImplAllegro5_InvalidateDeviceObjects ( )
2015-07-09 01:34:36 +08:00
{
2021-06-28 22:52:10 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
if ( bd - > Texture )
2015-07-09 01:53:30 +08:00
{
2023-02-07 19:24:42 +08:00
io . Fonts - > SetTexID ( 0 ) ;
2021-06-28 22:52:10 +08:00
al_destroy_bitmap ( bd - > Texture ) ;
2022-10-11 18:22:29 +08:00
bd - > Texture = nullptr ;
2015-07-09 01:53:30 +08:00
}
2021-06-28 22:52:10 +08:00
if ( bd - > MouseCursorInvisible )
2015-07-09 02:16:50 +08:00
{
2021-06-28 22:52:10 +08:00
al_destroy_mouse_cursor ( bd - > MouseCursorInvisible ) ;
2022-10-11 18:22:29 +08:00
bd - > MouseCursorInvisible = nullptr ;
2015-07-09 02:16:50 +08:00
}
2015-07-09 01:34:36 +08:00
}
2018-06-14 01:22:22 +08:00
# if ALLEGRO_HAS_CLIPBOARD
static const char * ImGui_ImplAllegro5_GetClipboardText ( void * )
{
2021-06-28 22:52:10 +08:00
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
if ( bd - > ClipboardTextData )
al_free ( bd - > ClipboardTextData ) ;
bd - > ClipboardTextData = al_get_clipboard_text ( bd - > Display ) ;
return bd - > ClipboardTextData ;
2018-06-14 01:22:22 +08:00
}
static void ImGui_ImplAllegro5_SetClipboardText ( void * , const char * text )
{
2021-06-28 22:52:10 +08:00
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
al_set_clipboard_text ( bd - > Display , text ) ;
2018-06-14 01:22:22 +08:00
}
# endif
2021-12-12 18:58:50 +08:00
static ImGuiKey ImGui_ImplAllegro5_KeyCodeToImGuiKey ( int key_code )
{
switch ( key_code )
{
case ALLEGRO_KEY_TAB : return ImGuiKey_Tab ;
case ALLEGRO_KEY_LEFT : return ImGuiKey_LeftArrow ;
case ALLEGRO_KEY_RIGHT : return ImGuiKey_RightArrow ;
case ALLEGRO_KEY_UP : return ImGuiKey_UpArrow ;
case ALLEGRO_KEY_DOWN : return ImGuiKey_DownArrow ;
case ALLEGRO_KEY_PGUP : return ImGuiKey_PageUp ;
case ALLEGRO_KEY_PGDN : return ImGuiKey_PageDown ;
case ALLEGRO_KEY_HOME : return ImGuiKey_Home ;
case ALLEGRO_KEY_END : return ImGuiKey_End ;
case ALLEGRO_KEY_INSERT : return ImGuiKey_Insert ;
case ALLEGRO_KEY_DELETE : return ImGuiKey_Delete ;
case ALLEGRO_KEY_BACKSPACE : return ImGuiKey_Backspace ;
case ALLEGRO_KEY_SPACE : return ImGuiKey_Space ;
case ALLEGRO_KEY_ENTER : return ImGuiKey_Enter ;
case ALLEGRO_KEY_ESCAPE : return ImGuiKey_Escape ;
case ALLEGRO_KEY_QUOTE : return ImGuiKey_Apostrophe ;
case ALLEGRO_KEY_COMMA : return ImGuiKey_Comma ;
case ALLEGRO_KEY_MINUS : return ImGuiKey_Minus ;
case ALLEGRO_KEY_FULLSTOP : return ImGuiKey_Period ;
case ALLEGRO_KEY_SLASH : return ImGuiKey_Slash ;
case ALLEGRO_KEY_SEMICOLON : return ImGuiKey_Semicolon ;
case ALLEGRO_KEY_EQUALS : return ImGuiKey_Equal ;
case ALLEGRO_KEY_OPENBRACE : return ImGuiKey_LeftBracket ;
case ALLEGRO_KEY_BACKSLASH : return ImGuiKey_Backslash ;
case ALLEGRO_KEY_CLOSEBRACE : return ImGuiKey_RightBracket ;
case ALLEGRO_KEY_TILDE : return ImGuiKey_GraveAccent ;
case ALLEGRO_KEY_CAPSLOCK : return ImGuiKey_CapsLock ;
case ALLEGRO_KEY_SCROLLLOCK : return ImGuiKey_ScrollLock ;
case ALLEGRO_KEY_NUMLOCK : return ImGuiKey_NumLock ;
case ALLEGRO_KEY_PRINTSCREEN : return ImGuiKey_PrintScreen ;
case ALLEGRO_KEY_PAUSE : return ImGuiKey_Pause ;
case ALLEGRO_KEY_PAD_0 : return ImGuiKey_Keypad0 ;
case ALLEGRO_KEY_PAD_1 : return ImGuiKey_Keypad1 ;
case ALLEGRO_KEY_PAD_2 : return ImGuiKey_Keypad2 ;
case ALLEGRO_KEY_PAD_3 : return ImGuiKey_Keypad3 ;
case ALLEGRO_KEY_PAD_4 : return ImGuiKey_Keypad4 ;
case ALLEGRO_KEY_PAD_5 : return ImGuiKey_Keypad5 ;
case ALLEGRO_KEY_PAD_6 : return ImGuiKey_Keypad6 ;
case ALLEGRO_KEY_PAD_7 : return ImGuiKey_Keypad7 ;
case ALLEGRO_KEY_PAD_8 : return ImGuiKey_Keypad8 ;
case ALLEGRO_KEY_PAD_9 : return ImGuiKey_Keypad9 ;
case ALLEGRO_KEY_PAD_DELETE : return ImGuiKey_KeypadDecimal ;
case ALLEGRO_KEY_PAD_SLASH : return ImGuiKey_KeypadDivide ;
case ALLEGRO_KEY_PAD_ASTERISK : return ImGuiKey_KeypadMultiply ;
case ALLEGRO_KEY_PAD_MINUS : return ImGuiKey_KeypadSubtract ;
case ALLEGRO_KEY_PAD_PLUS : return ImGuiKey_KeypadAdd ;
case ALLEGRO_KEY_PAD_ENTER : return ImGuiKey_KeypadEnter ;
case ALLEGRO_KEY_PAD_EQUALS : return ImGuiKey_KeypadEqual ;
2022-01-17 22:41:04 +08:00
case ALLEGRO_KEY_LCTRL : return ImGuiKey_LeftCtrl ;
2021-12-12 18:58:50 +08:00
case ALLEGRO_KEY_LSHIFT : return ImGuiKey_LeftShift ;
case ALLEGRO_KEY_ALT : return ImGuiKey_LeftAlt ;
case ALLEGRO_KEY_LWIN : return ImGuiKey_LeftSuper ;
2022-01-17 22:41:04 +08:00
case ALLEGRO_KEY_RCTRL : return ImGuiKey_RightCtrl ;
2021-12-12 18:58:50 +08:00
case ALLEGRO_KEY_RSHIFT : return ImGuiKey_RightShift ;
case ALLEGRO_KEY_ALTGR : return ImGuiKey_RightAlt ;
case ALLEGRO_KEY_RWIN : return ImGuiKey_RightSuper ;
case ALLEGRO_KEY_MENU : return ImGuiKey_Menu ;
case ALLEGRO_KEY_0 : return ImGuiKey_0 ;
case ALLEGRO_KEY_1 : return ImGuiKey_1 ;
case ALLEGRO_KEY_2 : return ImGuiKey_2 ;
case ALLEGRO_KEY_3 : return ImGuiKey_3 ;
case ALLEGRO_KEY_4 : return ImGuiKey_4 ;
case ALLEGRO_KEY_5 : return ImGuiKey_5 ;
case ALLEGRO_KEY_6 : return ImGuiKey_6 ;
case ALLEGRO_KEY_7 : return ImGuiKey_7 ;
case ALLEGRO_KEY_8 : return ImGuiKey_8 ;
case ALLEGRO_KEY_9 : return ImGuiKey_9 ;
case ALLEGRO_KEY_A : return ImGuiKey_A ;
case ALLEGRO_KEY_B : return ImGuiKey_B ;
case ALLEGRO_KEY_C : return ImGuiKey_C ;
case ALLEGRO_KEY_D : return ImGuiKey_D ;
case ALLEGRO_KEY_E : return ImGuiKey_E ;
case ALLEGRO_KEY_F : return ImGuiKey_F ;
case ALLEGRO_KEY_G : return ImGuiKey_G ;
case ALLEGRO_KEY_H : return ImGuiKey_H ;
case ALLEGRO_KEY_I : return ImGuiKey_I ;
case ALLEGRO_KEY_J : return ImGuiKey_J ;
case ALLEGRO_KEY_K : return ImGuiKey_K ;
case ALLEGRO_KEY_L : return ImGuiKey_L ;
case ALLEGRO_KEY_M : return ImGuiKey_M ;
case ALLEGRO_KEY_N : return ImGuiKey_N ;
case ALLEGRO_KEY_O : return ImGuiKey_O ;
case ALLEGRO_KEY_P : return ImGuiKey_P ;
case ALLEGRO_KEY_Q : return ImGuiKey_Q ;
case ALLEGRO_KEY_R : return ImGuiKey_R ;
case ALLEGRO_KEY_S : return ImGuiKey_S ;
case ALLEGRO_KEY_T : return ImGuiKey_T ;
case ALLEGRO_KEY_U : return ImGuiKey_U ;
case ALLEGRO_KEY_V : return ImGuiKey_V ;
case ALLEGRO_KEY_W : return ImGuiKey_W ;
case ALLEGRO_KEY_X : return ImGuiKey_X ;
case ALLEGRO_KEY_Y : return ImGuiKey_Y ;
case ALLEGRO_KEY_Z : return ImGuiKey_Z ;
case ALLEGRO_KEY_F1 : return ImGuiKey_F1 ;
case ALLEGRO_KEY_F2 : return ImGuiKey_F2 ;
case ALLEGRO_KEY_F3 : return ImGuiKey_F3 ;
case ALLEGRO_KEY_F4 : return ImGuiKey_F4 ;
case ALLEGRO_KEY_F5 : return ImGuiKey_F5 ;
case ALLEGRO_KEY_F6 : return ImGuiKey_F6 ;
case ALLEGRO_KEY_F7 : return ImGuiKey_F7 ;
case ALLEGRO_KEY_F8 : return ImGuiKey_F8 ;
case ALLEGRO_KEY_F9 : return ImGuiKey_F9 ;
case ALLEGRO_KEY_F10 : return ImGuiKey_F10 ;
case ALLEGRO_KEY_F11 : return ImGuiKey_F11 ;
case ALLEGRO_KEY_F12 : return ImGuiKey_F12 ;
default : return ImGuiKey_None ;
}
}
2018-06-09 01:37:33 +08:00
bool ImGui_ImplAllegro5_Init ( ALLEGRO_DISPLAY * display )
2015-07-09 01:34:36 +08:00
{
2021-06-28 22:52:10 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-10-11 18:22:29 +08:00
IM_ASSERT ( io . BackendPlatformUserData = = nullptr & & " Already initialized a platform backend! " ) ;
2021-06-28 22:52:10 +08:00
2020-10-12 23:34:22 +08:00
// Setup backend capabilities flags
2021-06-30 21:22:15 +08:00
ImGui_ImplAllegro5_Data * bd = IM_NEW ( ImGui_ImplAllegro5_Data ) ( ) ;
io . BackendPlatformUserData = ( void * ) bd ;
2018-12-01 01:18:15 +08:00
io . BackendPlatformName = io . BackendRendererName = " imgui_impl_allegro5 " ;
2021-06-30 21:22:15 +08:00
io . BackendFlags | = ImGuiBackendFlags_HasMouseCursors ; // We can honor GetMouseCursor() values (optional)
bd - > Display = display ;
2018-06-11 18:33:51 +08:00
2016-03-26 22:43:45 +08:00
// Create custom vertex declaration.
2019-11-20 18:58:25 +08:00
// Unfortunately Allegro doesn't support 32-bit packed colors so we have to convert them to 4 floats.
2015-07-09 02:41:09 +08:00
// We still use a custom declaration to use 'ALLEGRO_PRIM_TEX_COORD' instead of 'ALLEGRO_PRIM_TEX_COORD_PIXEL' else we can't do a reliable conversion.
2016-03-26 22:43:45 +08:00
ALLEGRO_VERTEX_ELEMENT elems [ ] =
2015-07-09 02:41:09 +08:00
{
2023-11-09 23:44:39 +08:00
{ ALLEGRO_PRIM_POSITION , ALLEGRO_PRIM_FLOAT_2 , offsetof ( ImDrawVertAllegro , pos ) } ,
{ ALLEGRO_PRIM_TEX_COORD , ALLEGRO_PRIM_FLOAT_2 , offsetof ( ImDrawVertAllegro , uv ) } ,
{ ALLEGRO_PRIM_COLOR_ATTR , 0 , offsetof ( ImDrawVertAllegro , col ) } ,
2015-07-09 02:41:09 +08:00
{ 0 , 0 , 0 }
} ;
2021-06-28 22:52:10 +08:00
bd - > VertexDecl = al_create_vertex_decl ( elems , sizeof ( ImDrawVertAllegro ) ) ;
2015-07-09 01:53:30 +08:00
2018-06-14 01:22:22 +08:00
# if ALLEGRO_HAS_CLIPBOARD
io . SetClipboardTextFn = ImGui_ImplAllegro5_SetClipboardText ;
io . GetClipboardTextFn = ImGui_ImplAllegro5_GetClipboardText ;
2022-10-11 18:22:29 +08:00
io . ClipboardUserData = nullptr ;
2018-06-14 01:22:22 +08:00
# endif
2015-07-09 01:53:30 +08:00
return true ;
2015-07-09 01:34:36 +08:00
}
2018-06-09 01:37:33 +08:00
void ImGui_ImplAllegro5_Shutdown ( )
2015-07-09 01:34:36 +08:00
{
2021-06-28 22:52:10 +08:00
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
IM_ASSERT ( bd ! = nullptr & & " No platform backend to shutdown, or already shutdown? " ) ;
2021-09-21 00:43:05 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2019-01-04 20:11:24 +08:00
2021-06-30 21:22:15 +08:00
ImGui_ImplAllegro5_InvalidateDeviceObjects ( ) ;
2021-06-28 22:52:10 +08:00
if ( bd - > VertexDecl )
al_destroy_vertex_decl ( bd - > VertexDecl ) ;
if ( bd - > ClipboardTextData )
al_free ( bd - > ClipboardTextData ) ;
2021-06-30 21:22:15 +08:00
2022-10-11 18:22:29 +08:00
io . BackendPlatformName = io . BackendRendererName = nullptr ;
2023-04-17 20:47:15 +08:00
io . BackendPlatformUserData = nullptr ;
io . BackendFlags & = ~ ImGuiBackendFlags_HasMouseCursors ;
2021-06-30 21:22:15 +08:00
IM_DELETE ( bd ) ;
2015-07-09 01:34:36 +08:00
}
2022-01-17 21:57:55 +08:00
// ev->keyboard.modifiers seems always zero so using that...
static void ImGui_ImplAllegro5_UpdateKeyModifiers ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
ALLEGRO_KEYBOARD_STATE keys ;
al_get_keyboard_state ( & keys ) ;
2022-09-23 00:58:33 +08:00
io . AddKeyEvent ( ImGuiMod_Ctrl , al_key_down ( & keys , ALLEGRO_KEY_LCTRL ) | | al_key_down ( & keys , ALLEGRO_KEY_RCTRL ) ) ;
io . AddKeyEvent ( ImGuiMod_Shift , al_key_down ( & keys , ALLEGRO_KEY_LSHIFT ) | | al_key_down ( & keys , ALLEGRO_KEY_RSHIFT ) ) ;
io . AddKeyEvent ( ImGuiMod_Alt , al_key_down ( & keys , ALLEGRO_KEY_ALT ) | | al_key_down ( & keys , ALLEGRO_KEY_ALTGR ) ) ;
io . AddKeyEvent ( ImGuiMod_Super , al_key_down ( & keys , ALLEGRO_KEY_LWIN ) | | al_key_down ( & keys , ALLEGRO_KEY_RWIN ) ) ;
2022-01-17 21:57:55 +08:00
}
Examples: Added a bunch of comments/referencs related to io.WantCaptureMouse, io.WantCaptureKeyboard (#1262, #1237, #1219, #635, #1058, #1051, #912, #533, #703, #446, #459, #364, #213, #52, and more)
2017-11-01 21:24:09 +08:00
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
2022-03-01 03:50:58 +08:00
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
Examples: Added a bunch of comments/referencs related to io.WantCaptureMouse, io.WantCaptureKeyboard (#1262, #1237, #1219, #635, #1058, #1051, #912, #533, #703, #446, #459, #364, #213, #52, and more)
2017-11-01 21:24:09 +08:00
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
2020-06-30 21:31:54 +08:00
bool ImGui_ImplAllegro5_ProcessEvent ( ALLEGRO_EVENT * ev )
2015-07-09 01:34:36 +08:00
{
2018-06-11 18:33:51 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 22:52:10 +08:00
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
2015-07-09 01:53:30 +08:00
2016-03-26 22:43:45 +08:00
switch ( ev - > type )
2015-07-09 01:53:30 +08:00
{
case ALLEGRO_EVENT_MOUSE_AXES :
2021-06-28 22:52:10 +08:00
if ( ev - > mouse . display = = bd - > Display )
2018-11-30 23:46:43 +08:00
{
2022-01-18 00:22:37 +08:00
io . AddMousePosEvent ( ev - > mouse . x , ev - > mouse . y ) ;
io . AddMouseWheelEvent ( - ev - > mouse . dw , ev - > mouse . dz ) ;
2018-11-30 23:46:43 +08:00
}
return true ;
case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN :
case ALLEGRO_EVENT_MOUSE_BUTTON_UP :
2022-01-18 00:22:37 +08:00
if ( ev - > mouse . display = = bd - > Display & & ev - > mouse . button > 0 & & ev - > mouse . button < = 5 )
io . AddMouseButtonEvent ( ev - > mouse . button - 1 , ev - > type = = ALLEGRO_EVENT_MOUSE_BUTTON_DOWN ) ;
2018-11-30 23:46:43 +08:00
return true ;
case ALLEGRO_EVENT_TOUCH_MOVE :
2021-06-28 22:52:10 +08:00
if ( ev - > touch . display = = bd - > Display )
2022-01-18 00:22:37 +08:00
io . AddMousePosEvent ( ev - > touch . x , ev - > touch . y ) ;
2018-11-30 23:46:43 +08:00
return true ;
case ALLEGRO_EVENT_TOUCH_BEGIN :
case ALLEGRO_EVENT_TOUCH_END :
case ALLEGRO_EVENT_TOUCH_CANCEL :
2021-06-28 22:52:10 +08:00
if ( ev - > touch . display = = bd - > Display & & ev - > touch . primary )
2022-01-18 00:22:37 +08:00
io . AddMouseButtonEvent ( 0 , ev - > type = = ALLEGRO_EVENT_TOUCH_BEGIN ) ;
2018-11-30 23:46:43 +08:00
return true ;
case ALLEGRO_EVENT_MOUSE_LEAVE_DISPLAY :
2021-06-28 22:52:10 +08:00
if ( ev - > mouse . display = = bd - > Display )
2022-01-18 00:22:37 +08:00
io . AddMousePosEvent ( - FLT_MAX , - FLT_MAX ) ;
2015-07-09 01:53:30 +08:00
return true ;
case ALLEGRO_EVENT_KEY_CHAR :
2021-06-28 22:52:10 +08:00
if ( ev - > keyboard . display = = bd - > Display )
2020-05-20 23:48:21 +08:00
if ( ev - > keyboard . unichar ! = 0 )
io . AddInputCharacter ( ( unsigned int ) ev - > keyboard . unichar ) ;
2015-07-09 01:53:30 +08:00
return true ;
2015-07-09 02:04:13 +08:00
case ALLEGRO_EVENT_KEY_DOWN :
2015-07-09 01:53:30 +08:00
case ALLEGRO_EVENT_KEY_UP :
2021-06-28 22:52:10 +08:00
if ( ev - > keyboard . display = = bd - > Display )
2021-12-12 18:58:50 +08:00
{
2022-01-17 21:57:55 +08:00
ImGui_ImplAllegro5_UpdateKeyModifiers ( ) ;
2021-12-12 18:58:50 +08:00
ImGuiKey key = ImGui_ImplAllegro5_KeyCodeToImGuiKey ( ev - > keyboard . keycode ) ;
io . AddKeyEvent ( key , ( ev - > type = = ALLEGRO_EVENT_KEY_DOWN ) ) ;
io . SetKeyEventNativeData ( key , ev - > keyboard . keycode , - 1 ) ; // To support legacy indexing (<1.87 user code)
}
2015-07-09 01:53:30 +08:00
return true ;
2021-08-03 02:17:26 +08:00
case ALLEGRO_EVENT_DISPLAY_SWITCH_OUT :
if ( ev - > display . source = = bd - > Display )
io . AddFocusEvent ( false ) ;
return true ;
case ALLEGRO_EVENT_DISPLAY_SWITCH_IN :
if ( ev - > display . source = = bd - > Display )
{
io . AddFocusEvent ( true ) ;
# if defined(ALLEGRO_UNSTABLE)
al_clear_keyboard_state ( bd - > Display ) ;
# endif
}
return true ;
2015-07-09 01:34:36 +08:00
}
2015-07-09 01:53:30 +08:00
return false ;
2015-07-09 01:34:36 +08:00
}
2018-06-11 18:33:51 +08:00
static void ImGui_ImplAllegro5_UpdateMouseCursor ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
if ( io . ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange )
return ;
2021-06-28 22:52:10 +08:00
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
2018-06-11 18:33:51 +08:00
ImGuiMouseCursor imgui_cursor = ImGui : : GetMouseCursor ( ) ;
if ( io . MouseDrawCursor | | imgui_cursor = = ImGuiMouseCursor_None )
{
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
2021-06-28 22:52:10 +08:00
al_set_mouse_cursor ( bd - > Display , bd - > MouseCursorInvisible ) ;
2018-06-11 18:33:51 +08:00
}
else
{
ALLEGRO_SYSTEM_MOUSE_CURSOR cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_DEFAULT ;
switch ( imgui_cursor )
{
case ImGuiMouseCursor_TextInput : cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_EDIT ; break ;
case ImGuiMouseCursor_ResizeAll : cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_MOVE ; break ;
case ImGuiMouseCursor_ResizeNS : cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_N ; break ;
case ImGuiMouseCursor_ResizeEW : cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_E ; break ;
case ImGuiMouseCursor_ResizeNESW : cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_NE ; break ;
case ImGuiMouseCursor_ResizeNWSE : cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_NW ; break ;
2019-12-02 16:52:06 +08:00
case ImGuiMouseCursor_NotAllowed : cursor_id = ALLEGRO_SYSTEM_MOUSE_CURSOR_UNAVAILABLE ; break ;
2018-06-11 18:33:51 +08:00
}
2021-06-28 22:52:10 +08:00
al_set_system_mouse_cursor ( bd - > Display , cursor_id ) ;
2018-06-11 18:33:51 +08:00
}
}
2018-06-09 01:37:33 +08:00
void ImGui_ImplAllegro5_NewFrame ( )
2015-07-09 01:34:36 +08:00
{
2021-06-28 22:52:10 +08:00
ImGui_ImplAllegro5_Data * bd = ImGui_ImplAllegro5_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
IM_ASSERT ( bd ! = nullptr & & " Did you call ImGui_ImplAllegro5_Init()? " ) ;
2021-06-29 23:53:41 +08:00
2021-06-28 22:52:10 +08:00
if ( ! bd - > Texture )
2018-06-09 01:37:33 +08:00
ImGui_ImplAllegro5_CreateDeviceObjects ( ) ;
2015-07-09 01:53:30 +08:00
2020-06-30 21:31:54 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2015-07-09 01:53:30 +08:00
// Setup display size (every frame to accommodate for window resizing)
int w , h ;
2021-06-28 22:52:10 +08:00
w = al_get_display_width ( bd - > Display ) ;
h = al_get_display_height ( bd - > Display ) ;
2015-07-09 01:53:30 +08:00
io . DisplaySize = ImVec2 ( ( float ) w , ( float ) h ) ;
// Setup time step
double current_time = al_get_time ( ) ;
2021-06-28 22:52:10 +08:00
io . DeltaTime = bd - > Time > 0.0 ? ( float ) ( current_time - bd - > Time ) : ( float ) ( 1.0f / 60.0f ) ;
bd - > Time = current_time ;
2015-07-09 01:53:30 +08:00
2022-01-17 21:57:55 +08:00
// Setup mouse cursor shape
2018-06-11 18:33:51 +08:00
ImGui_ImplAllegro5_UpdateMouseCursor ( ) ;
2015-07-09 01:34:36 +08:00
}
2023-07-13 17:27:52 +08:00
//-----------------------------------------------------------------------------
# endif // #ifndef IMGUI_DISABLE