1 /* Copyright (C) 2021-2023 Harry Godden (hgn) - All Rights Reserved */
6 * 1. layout is defined by subdividing
7 * 2. a parent node should never be resized by the content after creation
8 * 3. when the ui is in an interactive state, no controls should ever move
9 * 4. controls directly reference a memory location and use that as their
11 * 5. a maximum of ONE control per memory location can be drawn at any given
20 #include "vg/vg_tex.h"
21 #include "vg/vg_shader.h"
24 typedef ui_px ui_rect
[4];
25 typedef ui_px ui_point
[2];
26 typedef struct ui_vert ui_vert
;
33 /* Relative to cursor p0 */
36 k_ui_align_lwr
= 0xff,
37 k_ui_align_left
= 0x0000| 0x00,
38 k_ui_align_right
= 0x0000| 0x01,
39 k_ui_align_center
= 0x0000| 0x02,
41 k_ui_align_middle
= 0x0100,
42 k_ui_align_middle_left
= 0x0100| 0x00,
43 k_ui_align_middle_right
= 0x0100| 0x01,
44 k_ui_align_middle_center
= 0x0100| 0x02,
46 k_ui_align_bottom
= 0x0200,
47 k_ui_align_bottom_left
= 0x0200| 0x00,
48 k_ui_align_bottom_right
= 0x0200| 0x01,
49 k_ui_align_bottom_center
= 0x0200| 0x02,
61 enum ui_scheme_colour
{
76 static ui_px k_ui_widget_height
= 28,
80 typedef u32 ui_scheme
[8*4];
93 typedef struct ui_font ui_font
;
95 static const ui_font vg_ui_font_small
= {
116 #define UI_RGB( STDHEX ) 0xff000000 |\
117 ((STDHEX&0x000000ff)<<16) |\
118 ((STDHEX&0x0000ff00) ) |\
119 ((STDHEX&0x00ff0000)>>16)
121 #define UI_TEXTBOX_MULTILINE 0x1
122 #define UI_TEXTBOX_WRAP 0x2
123 #define UI_TEXTBOX_AUTOFOCUS 0x4
125 #define UI_MODAL_OK 0x0
126 #define UI_MODAL_GOOD 0x1
127 #define UI_MODAL_BAD 0x2
128 #define UI_MODAL_WARN 0x3
129 #define UI_MODAL_TYPE_BITS 0x3
131 #define UI_MOUSE_LEFT (SDL_BUTTON(SDL_BUTTON_LEFT))
132 #define UI_MOUSE_RIGHT (SDL_BUTTON(SDL_BUTTON_RIGHT))
133 #define UI_MOUSE_MIDDLE (SDL_BUTTON(SDL_BUTTON_MIDDLE))
137 #define UI_BOTTOM 0x4
141 struct ui_vert
*vertex_buffer
;
143 u32 max_verts
, max_indices
,
144 cur_vert
, cur_indice
,
145 vert_start
, indice_start
;
148 void *focused_control_id
; /* uses the memory location of various locking
154 u32 focused_control_hit
;
155 enum ui_control_type
{
157 k_ui_control_textbox
,
161 focused_control_type
;
163 union{ /* controls that can be focused */
165 int cursor_user
, cursor_pos
;
169 struct ui_textbox_callbacks
{
170 void (*enter
)( char *, u32
),
171 (*up
)( char *, u32
),
172 (*down
)( char *, u32
),
173 (*change
)( char *, u32
),
196 struct ui_modal_callbacks
{
203 GLuint tex_glyphs
, vao
, vbo
, ebo
, tex_bg
;
204 v2f bg_inverse_ratio
;
206 ui_px mouse
[2], mouse_click
[2];
208 u32 ignore_input_frames
;
211 ui_rect click_fader
, click_fader_end
;
212 float click_fade_opacity
;
226 SDL_Cursor
*cursor_map
[ k_ui_cursor_max
];
231 [ k_ui_bg
+0 ] = UI_RGB( 0x1d2021 ),
232 [ k_ui_bg
+1 ] = UI_RGB( 0x282828 ),
233 [ k_ui_bg
+2 ] = UI_RGB( 0x3c3836 ),
234 [ k_ui_bg
+3 ] = UI_RGB( 0x504945 ),
235 [ k_ui_bg
+4 ] = UI_RGB( 0x665c54 ),
236 [ k_ui_bg
+5 ] = UI_RGB( 0x7c6f64 ),
237 [ k_ui_bg
+6 ] = UI_RGB( 0x928374 ),
238 [ k_ui_bg
+7 ] = UI_RGB( 0xa89984 ),
240 [ k_ui_fg
+0 ] = UI_RGB( 0xebdbb2 ),
241 [ k_ui_fg
+1 ] = UI_RGB( 0xfbf1c7 ),
242 [ k_ui_fg
+2 ] = UI_RGB( 0xd5c4a1 ),
243 [ k_ui_fg
+3 ] = UI_RGB( 0xbdae93 ),
244 [ k_ui_fg
+4 ] = UI_RGB( 0xa89984 ),
245 [ k_ui_fg
+5 ] = UI_RGB( 0x000000 ),
246 [ k_ui_fg
+6 ] = UI_RGB( 0x000000 ),
247 [ k_ui_fg
+7 ] = UI_RGB( 0x000000 ),
249 [ k_ui_red
] = UI_RGB( 0xcc241d ),
250 [ k_ui_orange
] = UI_RGB( 0xd65d0e ),
251 [ k_ui_yellow
] = UI_RGB( 0xd79921 ),
252 [ k_ui_green
] = UI_RGB( 0x98971a ),
253 [ k_ui_aqua
] = UI_RGB( 0x689d6a ),
254 [ k_ui_blue
] = UI_RGB( 0x458588 ),
255 [ k_ui_purple
] = UI_RGB( 0xb16286 ),
256 [ k_ui_gray
] = UI_RGB( 0x928374 ),
257 [ k_ui_red
+ k_ui_brighter
] = UI_RGB( 0xfb4934 ),
258 [ k_ui_orange
+ k_ui_brighter
] = UI_RGB( 0xfe8019 ),
259 [ k_ui_yellow
+ k_ui_brighter
] = UI_RGB( 0xfabd2f ),
260 [ k_ui_green
+ k_ui_brighter
] = UI_RGB( 0xb8bb26 ),
261 [ k_ui_aqua
+ k_ui_brighter
] = UI_RGB( 0x8ec07c ),
262 [ k_ui_blue
+ k_ui_brighter
] = UI_RGB( 0x83a598 ),
263 [ k_ui_purple
+ k_ui_brighter
] = UI_RGB( 0xd3869b ),
264 [ k_ui_gray
+ k_ui_brighter
] = UI_RGB( 0xa89984 ),
266 .font
= &vg_ui_font_small
,
267 .colour
= {1.0f
,1.0f
,1.0f
,1.0f
},
268 .bg_inverse_ratio
= {1,1}
271 static struct vg_shader _shader_ui
={
272 .name
= "[vg] ui - transparent",
277 "layout (location=0) in vec2 a_co;"
278 "layout (location=1) in vec2 a_uv;"
279 "layout (location=2) in vec4 a_colour;"
281 "uniform vec2 uBGInverseRatio;"
283 "out vec4 aTexCoords;"
287 "vec4 proj_pos = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
288 "gl_Position = proj_pos;"
289 "aTexCoords = vec4( a_uv * 0.00390625, "
290 " (proj_pos.xy*0.5+0.5) * uBGInverseRatio );"
291 "aColour = a_colour;"
297 "uniform sampler2D uTexGlyphs;"
298 "uniform sampler2D uTexBG;"
299 "uniform vec4 uColour;"
300 "uniform float uSpread;"
301 "out vec4 FragColor;"
303 "in vec4 aTexCoords;"
306 "vec2 rand_hash22( vec2 p ){"
307 "vec3 p3 = fract(vec3(p.xyx) * 213.8976123);"
308 "p3 += dot(p3, p3.yzx+19.19);"
309 "return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));"
313 "vec4 diffuse = aColour;"
315 "vec4 avg = vec4(0.0);"
317 "if( aColour.a == 0.0 ){"
319 "avg.a = texture( uTexGlyphs, aTexCoords.xy ).r;"
322 "if( uSpread > 0.0001 ){"
323 "for( int i=0; i<4; i ++ ){"
324 "vec2 spread = rand_hash22(aTexCoords.zw+vec2(float(i)));"
325 "avg += texture( uTexBG, aTexCoords.zw + (spread-0.5)*uSpread );"
329 "avg.rgb = mix( avg.rgb, aColour.rgb, aColour.a );"
336 "FragColor = avg * uColour;"
341 static struct vg_shader _shader_ui_image
= {
342 .name
= "[vg] ui_image",
348 "layout (location=0) in vec2 a_co;"
349 "layout (location=1) in vec2 a_uv;"
350 "layout (location=2) in vec4 a_colour;"
353 "out vec2 aTexCoords;"
359 "gl_Position = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
360 "aTexCoords = a_uv * 0.00390625;"
361 "aColour = a_colour;"
370 "uniform sampler2D uTexImage;"
371 "uniform vec4 uColour;"
372 "out vec4 FragColor;"
374 "in vec2 aTexCoords;"
380 "vec4 colour = texture( uTexImage, aTexCoords );"
381 "FragColor = colour * uColour;"
386 static void _vg_ui_init(void){
387 if( !vg_shader_compile( &_shader_ui
) ||
388 !vg_shader_compile( &_shader_ui_image
) ){
389 vg_fatal_error( "Failed to compile ui shader" );
394 * ----------------------------------------
397 vg_ui
.max_indices
= 20000;
398 vg_ui
.max_verts
= 30000;
400 /* Generate the buffer we are gonna be drawing to */
401 glGenVertexArrays( 1, &vg_ui
.vao
);
402 glGenBuffers( 1, &vg_ui
.vbo
);
403 glGenBuffers( 1, &vg_ui
.ebo
);
405 glBindVertexArray( vg_ui
.vao
);
406 glBindBuffer( GL_ARRAY_BUFFER
, vg_ui
.vbo
);
408 glBufferData( GL_ARRAY_BUFFER
,
409 vg_ui
.max_verts
* sizeof( struct ui_vert
),
410 NULL
, GL_DYNAMIC_DRAW
);
411 glBindVertexArray( vg_ui
.vao
);
413 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER
, vg_ui
.ebo
);
414 glBufferData( GL_ELEMENT_ARRAY_BUFFER
,
415 vg_ui
.max_indices
* sizeof( u16
), NULL
, GL_DYNAMIC_DRAW
);
420 u32
const stride
= sizeof( struct ui_vert
);
423 glVertexAttribPointer( 0, 2, GL_SHORT
, GL_FALSE
, stride
,
424 (void *)offsetof( struct ui_vert
, co
) );
425 glEnableVertexAttribArray( 0 );
428 glVertexAttribPointer( 1, 2, GL_UNSIGNED_SHORT
, GL_FALSE
, stride
,
429 (void *)offsetof( struct ui_vert
, uv
) );
430 glEnableVertexAttribArray( 1 );
433 glVertexAttribPointer( 2, 4, GL_UNSIGNED_BYTE
, GL_TRUE
, stride
,
434 (void *)offsetof( struct ui_vert
, colour
) );
435 glEnableVertexAttribArray( 2 );
439 /* Alloc RAM default context */
440 u32 vert_size
= vg_ui
.max_verts
*sizeof(struct ui_vert
),
441 inds_size
= vg_align8( vg_ui
.max_indices
*sizeof(u16
) );
443 vg_ui
.vertex_buffer
= vg_linear_alloc( vg_mem
.rtmemory
, vert_size
);
444 vg_ui
.indice_buffer
= vg_linear_alloc( vg_mem
.rtmemory
, inds_size
);
447 * -----------------------------------------------------
450 /* Load default font */
452 #include "vg/vg_pxfont_thin.h"
455 u32 pixels
= 0, total
= 256*256, data
= 0;
458 while( pixels
< total
){
459 for( int b
= 31; b
>= 0; b
-- ){
460 image
[ pixels
++ ] = (compressed
[data
] & (0x1u
<< b
))? 0xffu
: 0x00u
;
462 if( pixels
>= total
){
470 glGenTextures( 1, &vg_ui
.tex_glyphs
);
471 glBindTexture( GL_TEXTURE_2D
, vg_ui
.tex_glyphs
);
472 glTexImage2D( GL_TEXTURE_2D
, 0, GL_R8
, 256, 256, 0,
473 GL_RED
, GL_UNSIGNED_BYTE
, image
);
476 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
477 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
478 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
479 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
483 * ---------------------------------------------------------------
486 vg_ui
.cursor_map
[ k_ui_cursor_default
] =
487 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_ARROW
);
488 vg_ui
.cursor_map
[ k_ui_cursor_hand
] =
489 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_HAND
);
490 vg_ui
.cursor_map
[ k_ui_cursor_ibeam
] =
491 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_IBEAM
);
499 static void rect_copy( ui_rect a
, ui_rect b
){
500 for( int i
=0; i
<4; i
++ )
504 static void ui_flush( enum ui_shader shader
, f32 w
, f32 h
){
505 u32 vertex_offset
= vg_ui
.vert_start
*sizeof(ui_vert
),
506 vertex_count
= vg_ui
.cur_vert
-vg_ui
.vert_start
,
507 vertex_size
= vertex_count
*sizeof(ui_vert
),
509 indice_offset
= vg_ui
.indice_start
*sizeof(u16
),
510 indice_count
= vg_ui
.cur_indice
-vg_ui
.indice_start
,
511 indice_size
= indice_count
* sizeof(u16
);
513 if( !vertex_size
|| !indice_size
)
516 glBindVertexArray( vg_ui
.vao
);
517 glBindBuffer( GL_ARRAY_BUFFER
, vg_ui
.vbo
);
518 glBufferSubData( GL_ARRAY_BUFFER
, vertex_offset
, vertex_size
,
519 vg_ui
.vertex_buffer
+vg_ui
.vert_start
);
521 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER
, vg_ui
.ebo
);
522 glBufferSubData( GL_ELEMENT_ARRAY_BUFFER
, indice_offset
, indice_size
,
523 vg_ui
.indice_buffer
+vg_ui
.indice_start
);
525 glDisable( GL_DEPTH_TEST
);
526 glEnable( GL_BLEND
);
527 glBlendFunc( GL_SRC_ALPHA
, GL_ONE_MINUS_SRC_ALPHA
);
528 glBlendEquation( GL_FUNC_ADD
);
529 glDisable( GL_CULL_FACE
);
531 m3x3f view
= M3X3_IDENTITY
;
532 m3x3_translate( view
, (v3f
){ -1.0f
, 1.0f
, 0.0f
} );
533 m3x3_scale( view
, (v3f
){ 1.0f
/(w
*0.5f
),
534 -1.0f
/(h
*0.5f
), 1.0f
} );
536 if( shader
== k_ui_shader_colour
){
537 glUseProgram( _shader_ui
.id
);
539 glUniformMatrix3fv( glGetUniformLocation( _shader_ui
.id
, "uPv" ), 1,
540 GL_FALSE
, (float *)view
);
541 glUniform4fv( glGetUniformLocation( _shader_ui
.id
, "uColour" ), 1,
544 glActiveTexture( GL_TEXTURE0
);
545 glBindTexture( GL_TEXTURE_2D
, vg_ui
.tex_glyphs
);
546 glUniform1i( glGetUniformLocation( _shader_ui
.id
, "uTexGlyphs" ), 0 );
548 glActiveTexture( GL_TEXTURE1
);
549 glBindTexture( GL_TEXTURE_2D
, vg_ui
.tex_bg
);
550 glUniform1i( glGetUniformLocation( _shader_ui
.id
, "uTexBG" ), 1 );
551 glUniform1f( glGetUniformLocation( _shader_ui
.id
, "uSpread" ),
553 glUniform2fv( glGetUniformLocation( _shader_ui
.id
, "uBGInverseRatio" ),
554 1, vg_ui
.bg_inverse_ratio
);
556 else if( shader
== k_ui_shader_image
){
557 glUseProgram( _shader_ui_image
.id
);
558 glUniformMatrix3fv( glGetUniformLocation( _shader_ui_image
.id
, "uPv" ), 1,
559 GL_FALSE
, (float *)view
);
560 glUniform1i( glGetUniformLocation(_shader_ui_image
.id
,"uTexImage"), 0 );
561 glUniform4fv( glGetUniformLocation( _shader_ui_image
.id
, "uColour" ), 1,
565 vg_fatal_error( "Invalid UI shader (%d)\n", shader
);
567 glDrawElements( GL_TRIANGLES
, indice_count
, GL_UNSIGNED_SHORT
,
568 (void *)(vg_ui
.indice_start
*sizeof(u16
)) );
570 glDisable( GL_BLEND
);
572 vg_ui
.indice_start
= vg_ui
.cur_indice
;
573 vg_ui
.vert_start
= vg_ui
.cur_vert
;
576 static void ui_fill_rect( ui_rect rect
, u32 colour
, ui_px uv
[4] ){
577 /* this if far from ideal but stops us from crashing */
578 if( (vg_ui
.cur_vert
+ 4 > vg_ui
.max_verts
) ||
579 (vg_ui
.cur_indice
+ 6 > vg_ui
.max_indices
))
582 struct ui_vert
*vertices
= &vg_ui
.vertex_buffer
[ vg_ui
.cur_vert
];
583 u16
*indices
= &vg_ui
.indice_buffer
[ vg_ui
.cur_indice
];
585 for( int i
=0; i
<4; i
++ ){
586 vertices
[i
].colour
= colour
;
589 vertices
[0].co
[0] = rect
[0];
590 vertices
[0].co
[1] = rect
[1];
591 vertices
[0].uv
[0] = uv
[0];
592 vertices
[0].uv
[1] = uv
[1];
593 vertices
[1].co
[0] = rect
[0]+rect
[2];
594 vertices
[1].co
[1] = rect
[1];
595 vertices
[1].uv
[0] = uv
[2];
596 vertices
[1].uv
[1] = uv
[1];
597 vertices
[2].co
[0] = rect
[0]+rect
[2];
598 vertices
[2].co
[1] = rect
[1]+rect
[3];
599 vertices
[2].uv
[0] = uv
[2];
600 vertices
[2].uv
[1] = uv
[3];
601 vertices
[3].co
[0] = rect
[0];
602 vertices
[3].co
[1] = rect
[1]+rect
[3];
603 vertices
[3].uv
[0] = uv
[0];
604 vertices
[3].uv
[1] = uv
[3];
605 u16 ind_start
= vg_ui
.cur_vert
;
607 u16 start
= vg_ui
.cur_vert
;
608 u32 mesh
[] = { 0,2,1, 0,3,2 };
610 for( u32 i
=0; i
<vg_list_size(mesh
); i
++ ){
611 indices
[i
] = start
+mesh
[i
];
614 vg_ui
.cur_indice
+= 6;
618 static void ui_fill( ui_rect rect
, u32 colour
){
619 ui_fill_rect( rect
, colour
, (ui_px
[4]){ 4,4,4,4 } );
622 static void ui_outline( ui_rect rect
, ui_px thickness
, u32 colour
, u32 mask
){
623 /* this if far from ideal but stops us from crashing */
624 if( (vg_ui
.cur_vert
+ 8 > vg_ui
.max_verts
) ||
625 (vg_ui
.cur_indice
+ 24 > vg_ui
.max_indices
))
628 struct ui_vert
*vertices
= &vg_ui
.vertex_buffer
[ vg_ui
.cur_vert
];
629 u16
*indices
= &vg_ui
.indice_buffer
[ vg_ui
.cur_indice
];
631 for( int i
=0; i
<8; i
++ ){
632 vertices
[i
].uv
[0] = 4;
633 vertices
[i
].uv
[1] = 4;
634 vertices
[i
].colour
= colour
;
637 vertices
[0].co
[0] = rect
[0];
638 vertices
[0].co
[1] = rect
[1];
639 vertices
[1].co
[0] = rect
[0]+rect
[2];
640 vertices
[1].co
[1] = rect
[1];
641 vertices
[2].co
[0] = rect
[0]+rect
[2];
642 vertices
[2].co
[1] = rect
[1]+rect
[3];
643 vertices
[3].co
[0] = rect
[0];
644 vertices
[3].co
[1] = rect
[1]+rect
[3];
645 vertices
[4].co
[0] = vertices
[0].co
[0]-thickness
;
646 vertices
[4].co
[1] = vertices
[0].co
[1]-thickness
;
647 vertices
[5].co
[0] = vertices
[1].co
[0]+thickness
;
648 vertices
[5].co
[1] = vertices
[1].co
[1]-thickness
;
649 vertices
[6].co
[0] = vertices
[2].co
[0]+thickness
;
650 vertices
[6].co
[1] = vertices
[2].co
[1]+thickness
;
651 vertices
[7].co
[0] = vertices
[3].co
[0]-thickness
;
652 vertices
[7].co
[1] = vertices
[3].co
[1]+thickness
;
654 u16 start
= vg_ui
.cur_vert
;
655 u32 mesh
[] = { 0,5,4, 0,1,5, 1,6,5, 1,2,6, 2,7,6, 2,3,7, 3,4,7, 3,0,4 };
658 mask
= UI_TOP
|UI_LEFT
|UI_BOTTOM
|UI_RIGHT
;
661 for( u32 i
=0; i
<vg_list_size(mesh
)/6; i
++ ){
662 if( (0x1<<i
) & mask
){
663 for( u32 j
=0; j
<6; j
++ )
664 indices
[c
++] = start
+mesh
[i
*6+j
];
668 vg_ui
.cur_indice
+= c
;
672 static void ui_split( ui_rect rect
,
673 enum ui_axis other
, ui_px width
, ui_px gap
,
674 ui_rect l
, ui_rect r
){
675 enum ui_axis dir
= other
^ 0x1;
677 if( width
< 0 ) width
= rect
[ 2+dir
] + width
;
680 rect_copy( rect
, temp
);
682 l
[ dir
] = temp
[ dir
];
683 r
[ dir
] = temp
[ dir
] + width
+ (gap
/2);
684 l
[ other
] = temp
[ other
];
685 r
[ other
] = temp
[ other
];
686 l
[ 2+dir
] = width
- (gap
/2);
687 r
[ 2+dir
] = temp
[ 2+dir
] - width
- (gap
/2);
688 l
[ 2+other
] = temp
[ 2+other
];
689 r
[ 2+other
] = temp
[ 2+other
];
692 static ui_px
ui_text_line_width( const char *str
);
694 static void ui_rect_center( ui_rect parent
, ui_rect rect
){
695 rect
[0] = parent
[0] + (parent
[2]-rect
[2])/2;
696 rect
[1] = parent
[1] + (parent
[3]-rect
[3])/2;
699 static void ui_fit_item( ui_rect rect
, ui_px size
[2], ui_rect d
){
700 i32 rp
= (i32
)rect
[2] * (i32
)size
[1],
701 rc
= (i32
)size
[0] * (i32
)rect
[3];
703 enum ui_axis dir
, other
;
704 if( rc
> rp
) dir
= k_ui_axis_h
;
705 else dir
= k_ui_axis_v
;
708 d
[2+dir
] = rect
[2+dir
];
709 d
[2+other
] = (rect
[2+dir
] * size
[other
]) / size
[dir
];
711 ui_rect_center( rect
, d
);
714 static void ui_split_ratio( ui_rect rect
, enum ui_axis dir
, float ratio
,
715 ui_px gap
, ui_rect l
, ui_rect r
){
716 ui_px width
= (float)rect
[ 2+(dir
^0x1) ] * ratio
;
717 ui_split( rect
, dir
, width
, gap
, l
, r
);
720 static void ui_rect_pad( ui_rect rect
, ui_px pad
[2] ){
727 static ui_px
ui_text_line_width( const char *str
){
729 const char *_c
= str
;
732 while( (c
= *(_c
++)) ){
733 if( c
>= 32 ) length
++;
734 else if( c
== '\n' ) break;
737 return length
* vg_ui
.font
->spacing
;
740 static ui_px
ui_text_string_height( const char *str
){
742 const char *_c
= str
;
745 while( (c
= *(_c
++)) ){
746 if( c
== '\n' ) height
++;
752 static ui_px
ui_text_aligned_x( const char *str
, ui_rect rect
, ui_px scale
,
753 enum ui_align align
){
754 enum ui_align lwr
= k_ui_align_lwr
& align
;
755 if( lwr
== k_ui_align_left
){
759 ui_px width
= ui_text_line_width( str
) * scale
;
761 if( lwr
== k_ui_align_right
)
762 return rect
[0] + rect
[2]-width
;
764 return rect
[0] + (rect
[2]-width
)/2;
768 static ui_px
ui_min( ui_px a
, ui_px b
){ return a
<b
?a
:b
; }
769 static ui_px
ui_max( ui_px a
, ui_px b
){ return a
>b
?a
:b
; }
770 static ui_px
ui_clamp( ui_px a
, ui_px min
, ui_px max
){
771 return ui_min( max
, ui_max( a
, min
) );
774 static int ui_clip( ui_rect parent
, ui_rect child
, ui_rect clipped
){
775 ui_px parent_max
[2], child_max
[2];
776 parent_max
[0] = parent
[0]+parent
[2];
777 parent_max
[1] = parent
[1]+parent
[3];
778 child_max
[0] = child
[0]+child
[2];
779 child_max
[1] = child
[1]+child
[3];
781 clipped
[0] = ui_clamp( child
[0], parent
[0], parent_max
[0] );
782 clipped
[1] = ui_clamp( child
[1], parent
[1], parent_max
[1] );
783 clipped
[2] = ui_clamp( child_max
[0], parent
[0], parent_max
[0] );
784 clipped
[3] = ui_clamp( child_max
[1], parent
[1], parent_max
[1] );
786 if( clipped
[0] == clipped
[2] ||
787 clipped
[1] == clipped
[3] )
790 clipped
[2] -= clipped
[0];
791 clipped
[3] -= clipped
[1];
796 static int ui_inside_rect( ui_rect rect
, ui_px co
[2] ){
797 if( co
[0] >= rect
[0] &&
799 co
[0] < rect
[0]+rect
[2] &&
800 co
[1] < rect
[1]+rect
[3] ){
807 static int ui_click_down( u32 mask
){
808 if( vg_ui
.ignore_input_frames
) return 0;
809 if( (vg_ui
.mouse_state
[0] & mask
) &&
810 !(vg_ui
.mouse_state
[1] & mask
) )
816 static int ui_clicking( u32 mask
){
817 if( vg_ui
.ignore_input_frames
) return 0;
818 return vg_ui
.mouse_state
[0] & mask
;
821 static int ui_click_up( u32 mask
){
822 if( vg_ui
.ignore_input_frames
) return 0;
823 if( (vg_ui
.mouse_state
[1] & mask
) &&
824 !(vg_ui
.mouse_state
[0] & mask
) )
830 static void ui_prerender(void){
832 vg_ui
.mouse_state
[1] = vg_ui
.mouse_state
[0];
833 vg_ui
.mouse_state
[0] = SDL_GetMouseState( &x
, &y
);
838 vg_ui
.cur_indice
= 0;
839 vg_ui
.vert_start
= 0;
840 vg_ui
.indice_start
= 0;
841 vg_ui
.focused_control_hit
= 0;
842 vg_ui
.cursor
= k_ui_cursor_default
;
843 vg_ui
.wants_mouse
= 0;
845 if( vg_ui
.ignore_input_frames
){
846 vg_ui
.ignore_input_frames
--;
850 if( ui_click_down(UI_MOUSE_LEFT
)||ui_click_down(UI_MOUSE_MIDDLE
) ){
851 vg_ui
.mouse_click
[0] = vg_ui
.mouse
[0];
852 vg_ui
.mouse_click
[1] = vg_ui
.mouse
[1];
856 static u32
ui_colour( enum ui_scheme_colour id
){
857 return vg_ui
.scheme
[ id
];
860 /* get an appropriately contrasting colour given the base */
861 static u32
ui_colourcont( enum ui_scheme_colour id
){
862 if ( id
< k_ui_bg
+6 ) return ui_colour( k_ui_fg
);
863 else if( id
< k_ui_fg
) return ui_colour( k_ui_bg
+1 );
864 else if( id
< k_ui_hue
) return ui_colour( k_ui_bg
+3 );
865 else if( id
< k_ui_red
+k_ui_brighter
) return ui_colour( k_ui_fg
);
866 else return ui_colour( k_ui_fg
+1 );
869 static void ui_hex_to_norm( u32 hex
, v4f norm
){
870 norm
[0] = ((hex
) & 0xff);
871 norm
[1] = ((hex
>>8 ) & 0xff);
872 norm
[2] = ((hex
>>16) & 0xff);
873 norm
[3] = ((hex
>>24) & 0xff);
874 v4_muls( norm
, 1.0f
/255.0f
, norm
);
877 static void ui_text_glyph( const struct ui_font
*font
, ui_px scale
,
878 u8 glyph
, ui_rect out_texcoords
){
879 glyph
-= font
->ascii_start
;
881 ui_px per_row
= font
->sheet_size
/ font
->glyph_width
,
882 column
= (ui_px
)glyph
% per_row
,
883 row
= (glyph
- column
) / per_row
;
885 out_texcoords
[0] = column
* font
->glyph_width
;
886 out_texcoords
[1] = row
* font
->glyph_height
+ font
->offset_y
;
887 out_texcoords
[2] = out_texcoords
[0] + font
->glyph_width
;
888 out_texcoords
[3] = out_texcoords
[1] + font
->glyph_height
;
891 static u32
ui_opacity( u32 colour
, f32 opacity
){
892 u32 alpha
= opacity
* 255.0f
;
893 return (colour
& 0x00ffffff) | (alpha
<< 24);
896 static u32
ui_ntext( ui_rect rect
, const char *str
, u32 len
, ui_px scale
,
897 enum ui_align align
, u32 colour
){
899 if( colour
== 0 ) colour
= ui_colour( k_ui_fg
);
901 colour
&= 0x00ffffff;
903 const char *_c
= str
;
906 text_cursor
[0] = ui_text_aligned_x( str
, rect
, scale
, align
);
907 text_cursor
[1] = rect
[1];
908 text_cursor
[2] = vg_ui
.font
->glyph_width
*scale
;
909 text_cursor
[3] = vg_ui
.font
->glyph_height
*scale
;
911 u32 printed_chars
= 0;
913 if( align
& (k_ui_align_middle
|k_ui_align_bottom
) ){
914 ui_px height
= ui_text_string_height( str
) * scale
;
916 if( align
& k_ui_align_bottom
)
917 text_cursor
[1] += rect
[3]-height
;
919 text_cursor
[1] += (rect
[3]-height
)/2;
922 while( (c
= *(_c
++)) ){
923 if( printed_chars
>= len
){
925 text_cursor
[1] += vg_ui
.font
->line_height
*scale
;
926 text_cursor
[0] = ui_text_aligned_x( _c
, rect
, scale
, align
);
927 text_cursor
[0] -= vg_ui
.font
->spacing
*scale
;
930 ui_text_glyph( vg_ui
.font
, scale
, '\xb6' /*FIXME*/, glyph
);
931 ui_fill_rect( text_cursor
, 0x00ffffff, glyph
);
932 text_cursor
[0] += vg_ui
.font
->spacing
*scale
;
936 text_cursor
[1] += vg_ui
.font
->line_height
*scale
;
937 text_cursor
[0] = ui_text_aligned_x( _c
, rect
, scale
, align
);
943 ui_text_glyph( vg_ui
.font
, scale
, c
, glyph
);
945 ui_rect cursor_clipped
;
946 if( ui_clip( rect
, text_cursor
, cursor_clipped
) ){
947 ui_fill_rect( cursor_clipped
, colour
, glyph
);
950 else if( c
== '\x1B' ){
954 for( int i
=0; i
<3; i
++ ){
960 case '0': colour
= ui_colour( k_ui_fg
); break;
961 case '3'|'0'<<8: colour
= ui_colour( k_ui_bg
); break;
962 case '3'|'1'<<8: colour
= ui_colour( k_ui_red
); break;
963 case '3'|'2'<<8: colour
= ui_colour( k_ui_green
); break;
964 case '3'|'3'<<8: colour
= ui_colour( k_ui_yellow
); break;
965 case '3'|'4'<<8: colour
= ui_colour( k_ui_blue
); break;
966 case '3'|'5'<<8: colour
= ui_colour( k_ui_purple
); break;
967 case '3'|'6'<<8: colour
= ui_colour( k_ui_aqua
); break;
968 case '3'|'7'<<8: colour
= 0xffffffff; break;
971 colour
&= 0x00ffffff;
975 colour_id
|= _c
[i
] << (i
*8);
985 else if( c
== '\t' ){
986 text_cursor
[0] += vg_ui
.font
->spacing
*scale
*4;
991 text_cursor
[0] += vg_ui
.font
->spacing
*scale
;
995 return printed_chars
;
998 static void ui_text( ui_rect rect
, const char *str
, ui_px scale
,
999 enum ui_align align
, u32 colour
){
1000 ui_ntext( rect
, str
, 1024, scale
, align
, colour
);
1004 * Standard layout stuff
1005 * -----------------------------------------------------------------------------
1008 static void ui_panel( ui_rect in_rect
, ui_rect out_panel
){
1009 ui_fill( in_rect
, ui_colour( k_ui_bg
+1 ) );
1010 ui_outline( in_rect
, 1, ui_colour( k_ui_bg
+7 ), 0 );
1011 rect_copy( in_rect
, out_panel
);
1012 ui_rect_pad( out_panel
, (ui_px
[2]){ k_ui_padding
, k_ui_padding
} );
1015 static void ui_label( ui_rect rect
, const char *text
, ui_px size
,
1016 ui_px gap
, ui_rect r
){
1018 ui_px width
= (ui_text_line_width(text
)+vg_ui
.font
->spacing
) * size
;
1019 ui_split( rect
, k_ui_axis_v
, width
, gap
, l
, r
);
1020 ui_text( l
, text
, 1, k_ui_align_middle_left
, 0 );
1023 static void ui_standard_widget( ui_rect inout_panel
, ui_rect out_rect
,
1025 ui_px height
= (count
* vg_ui
.font
->glyph_height
+ 18) * k_ui_scale
;
1026 ui_split( inout_panel
, k_ui_axis_h
, height
, k_ui_padding
,
1027 out_rect
, inout_panel
);
1030 static void ui_info( ui_rect inout_panel
, const char *text
){
1032 ui_standard_widget( inout_panel
, box
, 1 );
1033 ui_text( box
, text
, 1, k_ui_align_middle_left
, 0 );
1036 static void ui_image( ui_rect rect
, GLuint image
){
1037 ui_flush( k_ui_shader_colour
, vg
.window_x
, vg
.window_y
);
1038 glActiveTexture( GL_TEXTURE0
);
1039 glBindTexture( GL_TEXTURE_2D
, image
);
1040 ui_fill_rect( rect
, 0xffffffff, (ui_px
[4]){ 0,256,256,0 } );
1041 ui_flush( k_ui_shader_image
, vg
.window_x
, vg
.window_y
);
1044 static u32
v4f_u32_colour( v4f colour
){
1045 u32 r
= colour
[0] * 255.0f
,
1046 g
= colour
[1] * 255.0f
,
1047 b
= colour
[2] * 255.0f
,
1048 a
= colour
[3] * 255.0f
;
1050 return r
| (g
<<8) | (b
<<16) | (a
<<24);
1053 static void ui_defocus_all(void){
1054 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
1055 SDL_StopTextInput();
1056 if( vg_ui
.textbox
.callbacks
.escape
)
1057 vg_ui
.textbox
.callbacks
.escape();
1060 vg_ui
.focused_control_id
= NULL
;
1061 vg_ui
.focused_control_hit
= 0;
1062 vg_ui
.focused_control_type
= k_ui_control_none
;
1065 enum ui_button_state
{
1066 k_ui_button_none
= 0,
1067 k_ui_button_click
= 1,
1068 k_ui_button_holding_inside
= 2,
1069 k_ui_button_holding_outside
= 3,
1070 k_ui_button_hover
= 4
1073 static enum ui_button_state
ui_colourbutton( ui_rect rect
,
1074 enum ui_scheme_colour colour
){
1075 int clickup
= ui_click_up(UI_MOUSE_LEFT
),
1076 click
= ui_clicking(UI_MOUSE_LEFT
) | clickup
,
1077 target
= ui_inside_rect( rect
, vg_ui
.mouse_click
) && click
,
1078 hover
= ui_inside_rect( rect
, vg_ui
.mouse
);
1080 u32 col_base
= vg_ui
.scheme
[ colour
],
1081 col_highlight
= vg_ui
.scheme
[ k_ui_fg
],
1082 col_hover
= vg_ui
.scheme
[ colour
+ k_ui_brighter
];
1084 if( vg_ui
.focused_control_type
!= k_ui_control_none
){
1092 vg_ui
.cursor
= k_ui_cursor_hand
;
1099 ui_fill( rect
, col_highlight
);
1100 vg_ui
.ignore_input_frames
= 2;
1101 rect_copy( rect
, vg_ui
.click_fader
);
1103 rect_copy( rect
, vg_ui
.click_fader_end
);
1104 vg_ui
.click_fader_end
[3] = 0;
1105 ui_rect_center( rect
, vg_ui
.click_fader_end
);
1107 vg_ui
.click_fade_opacity
= 1.0f
;
1109 return k_ui_button_click
;
1112 ui_fill( rect
, col_highlight
);
1113 return k_ui_button_holding_inside
;
1117 ui_fill( rect
, col_base
);
1118 ui_outline( rect
, 1, col_highlight
, 0 );
1119 return k_ui_button_holding_outside
;
1123 ui_fill( rect
, col_base
);
1124 return k_ui_button_none
;
1129 ui_fill( rect
, col_hover
);
1130 return k_ui_button_hover
;
1133 ui_fill( rect
, col_base
);
1134 return k_ui_button_none
;
1139 static enum ui_button_state
ui_colourbutton_text(
1140 ui_rect rect
, const char *string
, ui_px scale
,
1141 enum ui_scheme_colour colour
){
1142 enum ui_button_state state
= ui_colourbutton( rect
, colour
);
1143 ui_rect t
= { 0,0, ui_text_line_width( string
)*scale
, 14*scale
};
1144 ui_rect_center( rect
, t
);
1146 u32 text_colour
= ui_colourcont(colour
);
1147 if( state
== k_ui_button_holding_inside
)
1148 text_colour
= colour
;
1150 ui_text( t
, string
, scale
, k_ui_align_left
, text_colour
);
1154 static enum ui_button_state
ui_button_text( ui_rect rect
,
1155 const char *string
, ui_px scale
){
1156 return ui_colourbutton_text( rect
, string
, scale
, k_ui_bg
+4 );
1159 static enum ui_button_state
ui_button( ui_rect inout_panel
,
1160 const char *string
){
1162 ui_standard_widget( inout_panel
, rect
, 1 );
1163 return ui_colourbutton_text( rect
, string
, 1, k_ui_bg
+4 );
1166 static void ui_enum_post(void);
1167 static void ui_postrender(void){
1168 if( vg_ui
.click_fade_opacity
> 0.0f
){
1169 float scale
= vg_ui
.click_fade_opacity
;
1170 scale
= vg_maxf( 1.0f
/255.0f
, scale
*scale
);
1172 vg_ui
.click_fade_opacity
-= vg
.time_frame_delta
* 3.8f
;
1173 u32 colour
= (0x00ffffff & ui_colour(k_ui_fg
))|0x7f000000;
1175 v4f begin
, end
, dest
;
1176 for( int i
=0; i
<4; i
++ ){
1177 begin
[i
] = vg_ui
.click_fader
[i
];
1178 end
[i
] = vg_ui
.click_fader_end
[i
]+1;
1181 v4_lerp( end
, begin
, scale
, dest
);
1184 for( int i
=0; i
<4; i
++ ){
1188 ui_fill( rect
, colour
);
1191 if( vg_ui
.focused_control_type
== k_ui_control_enum
){
1194 else if( vg_ui
.focused_control_type
== k_ui_control_modal
){
1195 ui_rect screen
= {0,0,vg
.window_x
,vg
.window_y
};
1196 ui_fill( screen
, 0xa0000000 );
1197 ui_rect box
= {0,0,400,200};
1199 u32 colour
= ui_colour(k_ui_fg
),
1200 type
= vg_ui
.modal
.options
& UI_MODAL_TYPE_BITS
;
1201 if ( type
== 1 ) colour
= ui_colour(k_ui_green
);
1202 else if( type
== 2 ) colour
= ui_colour(k_ui_red
);
1203 else if( type
== 3 ) colour
= ui_colour(k_ui_yellow
);
1205 ui_rect_center( screen
, box
);
1206 ui_fill( box
, ui_colour(k_ui_bg
) );
1207 ui_outline( box
, -1, colour
, 0 );
1210 rect_copy( box
, message
);
1212 ui_rect_center( box
, message
);
1214 ui_rect row0
, row1
, btn
;
1215 ui_split_ratio( message
, k_ui_axis_h
, 0.5f
, 0, row0
, row1
);
1216 row0
[0] += vg_ui
.font
->spacing
;
1217 ui_ntext( row0
, vg_ui
.modal
.message
, (box
[2]/vg_ui
.font
->spacing
)-2, 1,
1218 k_ui_align_left
, colour
);
1220 rect_copy( row1
, btn
);
1223 ui_rect_center( row1
, btn
);
1225 vg_ui
.focused_control_type
= k_ui_control_none
; /* HACK */
1226 if( ui_button_text( btn
, "OK", 1 ) != 1 )
1227 vg_ui
.focused_control_hit
= 1;
1228 vg_ui
.focused_control_type
= k_ui_control_modal
; /* HACK */
1229 vg_ui
.wants_mouse
= 1;
1232 ui_flush( k_ui_shader_colour
, vg
.window_x
, vg
.window_y
);
1234 if( !vg_ui
.focused_control_hit
){
1238 if( vg_ui
.wants_mouse
){
1239 SDL_SetWindowGrab( vg
.window
, SDL_FALSE
);
1240 SDL_SetRelativeMouseMode( SDL_FALSE
);
1243 SDL_SetWindowGrab( vg
.window
, SDL_TRUE
);
1244 SDL_SetRelativeMouseMode( SDL_TRUE
);
1247 SDL_SetCursor( vg_ui
.cursor_map
[ vg_ui
.cursor
] );
1253 * -----------------------------------------------------------------------------
1256 static int ui_checkbox( ui_rect inout_panel
, const char *str_label
, i32
*data
){
1257 ui_rect rect
, label
, box
;
1258 ui_standard_widget( inout_panel
, rect
, 1 );
1260 ui_split( rect
, k_ui_axis_v
, -rect
[3], 0, label
, box
);
1261 ui_text( label
, str_label
, k_ui_scale
, k_ui_align_middle_left
, 0 );
1263 int changed
= ui_colourbutton( box
, k_ui_bg
)==1;
1265 *data
= (*data
) ^ 0x1;
1268 ui_rect_pad( box
, (ui_px
[2]){4,4} );
1269 ui_fill( box
, ui_colour( k_ui_orange
) );
1277 * -----------------------------------------------------------------------------
1281 * unfortunately no return value since we only find out that event in the
1284 static void ui_enum( ui_rect inout_panel
, const char *str_label
,
1285 struct ui_enum_opt
*options
, u32 len
, i32
*value
){
1286 ui_rect rect
, label
, box
;
1287 ui_standard_widget( inout_panel
, rect
, 1 );
1288 ui_label( rect
, str_label
, k_ui_scale
, 0, box
);
1290 const char *display
= "OUT OF RANGE";
1292 for( u32 i
=0; i
<len
; i
++ ){
1293 if( *value
== options
[i
].value
){
1294 display
= options
[i
].alias
;
1300 if( ui_button_text( box
, display
, k_ui_scale
) == 1 ){
1301 vg_ui
.focused_control_type
= k_ui_control_enum
;
1302 vg_ui
.ptr_enum
= value
;
1303 vg_ui
._enum
.option_count
= len
;
1304 vg_ui
._enum
.options
= options
;
1305 rect_copy( box
, vg_ui
._enum
.rect
);
1309 ui_outline( box
, 1, ui_colour(k_ui_red
), 0 );
1312 static void ui_enum_post(void){
1314 rect_copy( vg_ui
._enum
.rect
, drawer
);
1315 drawer
[3] *= vg_ui
._enum
.option_count
;
1318 int clickany
= ui_click_up(UI_MOUSE_LEFT
|UI_MOUSE_RIGHT
|UI_MOUSE_MIDDLE
),
1319 hover
= ui_inside_rect( drawer
, vg_ui
.mouse
);
1321 if( clickany
&& !hover
){
1326 vg_ui
.focused_control_type
= k_ui_control_none
;
1327 i32
*value
= vg_ui
.ptr_enum
;
1329 for( u32 i
=0; i
<vg_ui
._enum
.option_count
; i
++ ){
1331 ui_split( drawer
, k_ui_axis_h
, vg_ui
._enum
.rect
[3], 0, button
,drawer
);
1333 enum ui_scheme_colour colour
= k_ui_bg
+3;
1334 if( vg_ui
._enum
.options
[i
].value
== *value
)
1335 colour
= k_ui_orange
;
1337 if( ui_colourbutton_text( button
, vg_ui
._enum
.options
[i
].alias
,
1338 k_ui_scale
, colour
) == 1 ){
1339 *value
= vg_ui
._enum
.options
[i
].value
;
1345 vg_ui
.focused_control_type
= k_ui_control_enum
;
1348 vg_ui
.focused_control_hit
= 1;
1353 * -----------------------------------------------------------------------------
1356 static void _ui_textbox_make_selection( int *start
, int *end
){
1357 *start
= VG_MIN( vg_ui
.textbox
.cursor_pos
, vg_ui
.textbox
.cursor_user
);
1358 *end
= VG_MAX( vg_ui
.textbox
.cursor_pos
, vg_ui
.textbox
.cursor_user
);
1361 static void _ui_textbox_move_cursor( int *cursor0
, int *cursor1
,
1362 int dir
, int snap_together
){
1363 *cursor0
= VG_MAX( 0, vg_ui
.textbox
.cursor_user
+ dir
);
1366 VG_MIN( vg_ui
.textbox
.len
-1, strlen( vg_ui
.textbuf
)),
1370 *cursor1
= *cursor0
;
1373 static int _ui_textbox_makeroom( int datastart
, int length
){
1374 int move_to
= VG_MIN( datastart
+length
, vg_ui
.textbox
.len
-1 );
1375 int move_amount
= strlen( vg_ui
.textbuf
)-datastart
;
1376 int move_end
= VG_MIN( move_to
+move_amount
, vg_ui
.textbox
.len
-1 );
1377 move_amount
= move_end
-move_to
;
1380 memmove( &vg_ui
.textbuf
[ move_to
],
1381 &vg_ui
.textbuf
[ datastart
],
1384 vg_ui
.textbuf
[ move_end
] = '\0';
1386 return VG_MIN( length
, vg_ui
.textbox
.len
-datastart
-1 );
1389 static int _ui_textbox_delete_char( int direction
){
1391 _ui_textbox_make_selection( &start
, &end
);
1393 /* There is no selection */
1395 if( direction
== 1 ) end
= VG_MIN( end
+1, strlen( vg_ui
.textbuf
) );
1396 else if( direction
== -1 ) start
= VG_MAX( start
-1, 0 );
1399 /* Still no selction, no need to do anything */
1403 /* Copy the end->terminator to start */
1404 int remaining_length
= strlen( vg_ui
.textbuf
)+1-end
;
1405 memmove( &vg_ui
.textbuf
[ start
],
1406 &vg_ui
.textbuf
[ end
],
1411 static void _ui_textbox_to_clipboard(void){
1413 _ui_textbox_make_selection( &start
, &end
);
1417 memcpy( buffer
, &vg_ui
.textbuf
[ start
], end
-start
);
1418 buffer
[ end
-start
] = 0x00;
1419 SDL_SetClipboardText( buffer
);
1423 static void ui_start_modal( const char *message
, u32 options
);
1424 static void _ui_textbox_clipboard_paste(void){
1425 if( !SDL_HasClipboardText() )
1428 char *text
= SDL_GetClipboardText();
1433 int datastart
= _ui_textbox_delete_char( 0 );
1434 int length
= strlen( text
);
1436 if( (vg_ui
.textbox
.len
- strlen(vg_ui
.textbuf
)) < length
){
1437 ui_start_modal( "Clipboard content exceeds buffer size.", UI_MODAL_BAD
);
1441 int cpylength
= _ui_textbox_makeroom( datastart
, length
);
1443 memcpy( vg_ui
.textbuf
+ datastart
, text
, cpylength
);
1444 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
,
1445 &vg_ui
.textbox
.cursor_pos
, cpylength
, 1 );
1449 static void _ui_textbox_put_char( char c
){
1450 vg_ui
.textbox
.cursor_user
= _ui_textbox_delete_char(0);
1451 if( (vg_ui
.textbox
.len
- strlen(vg_ui
.textbuf
)) <= 1 ) return;
1453 if( _ui_textbox_makeroom( vg_ui
.textbox
.cursor_user
, 1 ) )
1454 vg_ui
.textbuf
[ vg_ui
.textbox
.cursor_user
] = c
;
1456 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
,
1457 &vg_ui
.textbox
.cursor_pos
, 1, 1 );
1460 /* Receed secondary cursor */
1461 static void _ui_textbox_left_select(void){
1462 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
, NULL
, -1, 0 );
1465 /* Match and receed both cursors */
1466 static void _ui_textbox_left(void){
1467 int cursor_diff
= vg_ui
.textbox
.cursor_pos
- vg_ui
.textbox
.cursor_user
? 0: 1;
1469 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
,
1470 &vg_ui
.textbox
.cursor_pos
, -cursor_diff
, 1 );
1473 static void _ui_textbox_up(void){
1474 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1475 int line_begin
= vg_ui
.textbox
.cursor_user
;
1477 while( line_begin
){
1478 if( vg_ui
.textbuf
[ line_begin
-1 ] == '\n' ){
1486 int line_above_begin
= line_begin
-1;
1488 while( line_above_begin
){
1489 if( vg_ui
.textbuf
[ line_above_begin
-1 ] == '\n' ){
1493 line_above_begin
--;
1496 int offset
= vg_ui
.textbox
.cursor_user
- line_begin
,
1497 line_length_above
= line_begin
- line_above_begin
-1;
1499 offset
= VG_MIN( line_length_above
, offset
);
1501 vg_ui
.textbox
.cursor_user
= line_above_begin
+offset
;
1502 vg_ui
.textbox
.cursor_pos
= line_above_begin
+offset
;
1505 vg_ui
.textbox
.cursor_user
= line_begin
;
1506 vg_ui
.textbox
.cursor_pos
= line_begin
;
1510 if( vg_ui
.textbox
.callbacks
.up
){
1511 vg_ui
.textbox
.callbacks
.up( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1516 static void _ui_textbox_down(void){
1517 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1518 int line_begin
= vg_ui
.textbox
.cursor_user
;
1520 while( line_begin
){
1521 if( vg_ui
.textbuf
[ line_begin
-1 ] == '\n' ){
1528 int line_below_begin
= vg_ui
.textbox
.cursor_user
;
1531 if( vg_ui
.textbuf
[ line_below_begin
] == '\0' ){
1532 vg_ui
.textbox
.cursor_user
= line_below_begin
;
1533 vg_ui
.textbox
.cursor_pos
= line_below_begin
;
1537 if( vg_ui
.textbuf
[ line_below_begin
] == '\n' ){
1538 line_below_begin
++;
1542 line_below_begin
++;
1545 int line_below_end
= line_below_begin
;
1547 if( vg_ui
.textbuf
[ line_below_end
] == '\0' ||
1548 vg_ui
.textbuf
[ line_below_end
] == '\n' ){
1555 int offset
= vg_ui
.textbox
.cursor_user
- line_begin
,
1556 line_length_below
= line_below_end
- line_below_begin
-1;
1558 offset
= VG_MIN( line_length_below
, offset
);
1560 vg_ui
.textbox
.cursor_user
= line_below_begin
+offset
;
1561 vg_ui
.textbox
.cursor_pos
= line_below_begin
+offset
;
1564 if( vg_ui
.textbox
.callbacks
.down
){
1565 vg_ui
.textbox
.callbacks
.down( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1570 static void _ui_textbox_right_select(void){
1571 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
, NULL
, 1, 0 );
1574 static void _ui_textbox_right(void){
1575 int cursor_diff
= vg_ui
.textbox
.cursor_pos
- vg_ui
.textbox
.cursor_user
? 0: 1;
1577 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
,
1578 &vg_ui
.textbox
.cursor_pos
, +cursor_diff
, 1 );
1581 static void _ui_textbox_backspace(void){
1582 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
1583 vg_ui
.textbox
.cursor_user
= _ui_textbox_delete_char( -1 );
1584 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1586 if( vg_ui
.textbox
.callbacks
.change
){
1587 vg_ui
.textbox
.callbacks
.change( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1592 static void _ui_textbox_delete(void){
1593 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
1594 vg_ui
.textbox
.cursor_user
= _ui_textbox_delete_char( 1 );
1595 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1597 if( vg_ui
.textbox
.callbacks
.change
){
1598 vg_ui
.textbox
.callbacks
.change( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1603 static void _ui_textbox_home_select(void){
1604 i32 start
= vg_ui
.textbox
.cursor_user
;
1606 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1608 if( vg_ui
.textbuf
[start
-1] == '\n' )
1617 vg_ui
.textbox
.cursor_user
= start
;
1620 static void _ui_textbox_home(void){
1621 _ui_textbox_home_select();
1622 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1625 static void _ui_textbox_end_select(void){
1626 i32 end
= vg_ui
.textbox
.cursor_user
;
1628 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1629 while( vg_ui
.textbuf
[end
] ){
1630 if( vg_ui
.textbuf
[end
] == '\n' )
1637 end
= VG_MIN( vg_ui
.textbox
.len
-1, strlen(vg_ui
.textbuf
) );
1639 vg_ui
.textbox
.cursor_user
= end
;
1642 static void _ui_textbox_end(void){
1643 _ui_textbox_end_select();
1644 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1647 static void _ui_textbox_select_all(void){
1648 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
, NULL
, 10000, 0);
1649 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_pos
, NULL
, -10000, 0);
1652 static void _ui_textbox_cut(void){
1653 _ui_textbox_to_clipboard();
1654 vg_ui
.textbox
.cursor_user
= _ui_textbox_delete_char(0);
1655 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1658 static void _ui_textbox_enter(void){
1659 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
1660 vg_ui
.ignore_input_frames
= 2;
1662 if( vg_ui
.textbox
.callbacks
.enter
)
1663 vg_ui
.textbox
.callbacks
.enter( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1665 if( vg_ui
.focused_control_type
!= k_ui_control_textbox
) return;
1667 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
)
1668 _ui_textbox_put_char( '\n' );
1670 if( !(vg_ui
.textbox
.flags
& UI_TEXTBOX_AUTOFOCUS
) )
1677 * based on a visual character coordinate relative to the anchor of the textbox,
1678 * this works out the linear place in the buffer that coordinate maps to
1680 * input coordinates go in co[0], co[1], and the result index is in co[2]
1682 static void _ui_textbox_calc_index_from_grid( int co
[3], int wrap_length
){
1686 while( (c
= vg_ui
.textbuf
[i
[2]]) ){
1687 if( i
[1]==co
[1] && i
[0]>=co
[0] ) break;
1689 if( i
[0] >= wrap_length
){
1694 if( c
>= 32 && c
<= 126 ){
1698 else if( c
== '\n' ){
1701 if( i
[1] > co
[1] ) break;
1715 * based on the index specied in co[2], work out the visual character
1716 * coordinates and store them in co[0], co[1]
1718 static void _ui_textbox_index_calc_coords( int co
[3], int wrap_length
){
1725 while( (c
= vg_ui
.textbuf
[i
++]) ){
1726 if( i
> co
[2] ) break;
1727 if( co
[0] >= wrap_length
){
1731 if( c
>= 32 && c
<= 126 ) co
[0] ++;
1732 else if( c
== '\n' ){
1740 * calculate the number of characters remaining until either:
1741 * - the wrap_length limit is hit
1742 * - end of the line/string
1744 * index must be fully populated with visual X/Y, and linear index
1746 static int _ui_textbox_run_remaining( int index
[3], int wrap_length
){
1747 int i
=0, printed_chars
=0;
1749 while( (c
= vg_ui
.textbuf
[index
[2] + (i
++)]) ){
1750 if( index
[0]+i
>= wrap_length
) break;
1751 if( c
>= 32 && c
<= 126 ) printed_chars
++;
1752 else if( c
== '\n' ) break;
1755 return printed_chars
+1;
1758 static int ui_textbox( ui_rect inout_panel
, const char *label
,
1759 char *buf
, u32 len
, u32 lines
, u32 flags
,
1760 struct ui_textbox_callbacks
*callbacks
){
1761 assert( lines
> 0 );
1764 if( lines
> 1 ) flags
|= UI_TEXTBOX_MULTILINE
;
1767 ui_standard_widget( inout_panel
, rect
, lines
);
1770 ui_label( rect
, label
, 1, 0, rect
);
1772 int clickup
= ui_click_up(UI_MOUSE_LEFT
),
1773 clickdown
= ui_click_down(UI_MOUSE_LEFT
),
1774 click
= ui_clicking(UI_MOUSE_LEFT
) | clickup
,
1775 target
= ui_inside_rect( rect
, vg_ui
.mouse_click
) && click
,
1776 hover
= ui_inside_rect( rect
, vg_ui
.mouse
);
1778 /* allow instant transitions from textbox->textbox */
1779 if( (vg_ui
.focused_control_type
!= k_ui_control_none
) &&
1780 (vg_ui
.focused_control_type
!= k_ui_control_textbox
) ){
1786 flags
&= ~UI_TEXTBOX_AUTOFOCUS
;
1789 u32 col_base
= ui_colour( k_ui_bg
),
1790 col_highlight
= ui_colour( k_ui_fg
),
1791 col_cursor
= (0x00ffffff & ui_colour(k_ui_fg
))|0x7f000000;
1796 rect_copy( rect
, text_rect
);
1798 if( flags
& UI_TEXTBOX_MULTILINE
) text_rect
[3] = rect
[3]-16;
1799 else text_rect
[3] = vg_ui
.font
->line_height
;
1802 ui_rect_center( rect
, text_rect
);
1804 ui_px wrap_length
= 1024;
1806 if( flags
& UI_TEXTBOX_WRAP
)
1807 wrap_length
= text_rect
[2] / vg_ui
.font
->spacing
;
1810 vg_ui
.cursor
= k_ui_cursor_ibeam
;
1813 if( vg_ui
.focused_control_id
== buf
){
1814 ui_fill( rect
, col_base
);
1815 ui_ntext( text_rect
, buf
, wrap_length
, 1, k_ui_align_left
, 0 );
1817 if( !(flags
& UI_TEXTBOX_AUTOFOCUS
) && ((clickup
||clickdown
) && !target
)){
1821 vg_ui
.focused_control_hit
= 1;
1822 if( click
&& target
){
1824 (vg_ui
.mouse_click
[0] - text_rect
[0]) / vg_ui
.font
->spacing
,
1825 (vg_ui
.mouse_click
[1] - text_rect
[1]) / vg_ui
.font
->line_height
,
1829 (vg_ui
.mouse
[0] - text_rect
[0]) / vg_ui
.font
->spacing
,
1830 (vg_ui
.mouse
[1] - text_rect
[1]) / vg_ui
.font
->line_height
,
1834 if( flags
& UI_TEXTBOX_MULTILINE
){
1835 _ui_textbox_calc_index_from_grid( p0
, wrap_length
);
1836 _ui_textbox_calc_index_from_grid( p1
, wrap_length
);
1838 vg_ui
.textbox
.cursor_pos
= p0
[2];
1839 vg_ui
.textbox
.cursor_user
= p1
[2];
1842 int max
= strlen( buf
);
1843 vg_ui
.textbox
.cursor_pos
= VG_MAX( 0, VG_MIN( max
, p0
[0] )),
1844 vg_ui
.textbox
.cursor_user
= VG_MAX( 0, VG_MIN( max
, p1
[0] ));
1848 ui_outline( rect
, -2, vg_ui
.scheme
[ k_ui_orange
], 0 );
1852 int c0
= vg_ui
.textbox
.cursor_pos
,
1853 c1
= vg_ui
.textbox
.cursor_user
,
1854 start
= VG_MIN( c0
, c1
),
1855 end
= VG_MAX( c0
, c1
),
1858 if( flags
& (UI_TEXTBOX_WRAP
|UI_TEXTBOX_MULTILINE
) ){
1859 int pos
[3], remaining
= chars
;
1862 _ui_textbox_index_calc_coords( pos
, wrap_length
);
1865 cursor
[0] = text_rect
[0] + pos
[0]*vg_ui
.font
->spacing
-1;
1866 cursor
[1] = text_rect
[1] + pos
[1]*14;
1869 ui_fill( cursor
, col_cursor
);
1870 rect_copy( cursor
, vg_ui
.click_fader_end
);
1874 int run
= _ui_textbox_run_remaining( pos
, wrap_length
);
1875 run
= VG_MIN( run
, remaining
);
1877 cursor
[0] = text_rect
[0] + pos
[0]*vg_ui
.font
->spacing
-1;
1878 cursor
[1] = text_rect
[1] + pos
[1]*14;
1879 cursor
[2] = (float)(run
)*(float)vg_ui
.font
->spacing
;
1882 ui_fill( cursor
, col_cursor
);
1889 rect_copy( cursor
, vg_ui
.click_fader_end
);
1893 cursor
[0] = text_rect
[0] + start
*vg_ui
.font
->spacing
-1;
1894 cursor
[1] = text_rect
[1];
1901 cursor
[2] = (float)(chars
)*(float)vg_ui
.font
->spacing
;
1904 if( (vg_ui
.click_fade_opacity
<=0.0f
) &&
1905 ui_clip( rect
, cursor
, cursor
) ){
1906 ui_fill( cursor
, col_cursor
);
1909 rect_copy( cursor
, vg_ui
.click_fader_end
);
1916 if( click
|| (flags
& UI_TEXTBOX_AUTOFOCUS
) ){
1917 if( (target
&& hover
) || (flags
& UI_TEXTBOX_AUTOFOCUS
) ){
1920 ui_fill( rect
, col_highlight
);
1921 vg_ui
.ignore_input_frames
= 2;
1922 rect_copy( rect
, vg_ui
.click_fader
);
1923 rect_copy( rect
, vg_ui
.click_fader_end
);
1925 vg_ui
.click_fade_opacity
= 1.0f
;
1926 vg_ui
.textbuf
= buf
;
1927 vg_ui
.focused_control_hit
= 1;
1928 vg_ui
.focused_control_type
= k_ui_control_textbox
;
1929 vg_ui
.textbox
.len
= len
;
1930 vg_ui
.textbox
.flags
= flags
;
1931 vg_ui
.textbox
.cursor_pos
= 0;
1932 vg_ui
.textbox
.cursor_user
= 0;
1935 vg_ui
.textbox
.callbacks
= *callbacks
;
1938 vg_ui
.textbox
.callbacks
.change
= NULL
;
1939 vg_ui
.textbox
.callbacks
.down
= NULL
;
1940 vg_ui
.textbox
.callbacks
.up
= NULL
;
1941 vg_ui
.textbox
.callbacks
.enter
= NULL
;
1944 SDL_StartTextInput();
1948 ui_fill( rect
, col_base
);
1951 ui_outline( rect
, -1, col_highlight
, 0 );
1954 ui_ntext( text_rect
, buf
, wrap_length
, 1, k_ui_align_left
, 0 );
1960 * -----------------------------------------------------------------------------
1963 static void ui_tabs( ui_rect inout_panel
, ui_rect out_content_panel
,
1964 const char **titles
, u32 count
, i32
*page
){
1966 ui_standard_widget( inout_panel
, bar
, 1 );
1968 i32 cur_page
= *page
;
1970 f32 width
= (f32
)inout_panel
[2] / (f32
)count
;
1972 ui_px h
= (inout_panel
[1] + inout_panel
[3]) - (bar
[1]+bar
[3]);
1973 inout_panel
[1] = bar
[1]+bar
[3];
1976 ui_fill( inout_panel
, ui_colour( k_ui_bg
+2 ) );
1977 ui_outline( inout_panel
, 1, ui_colour( k_ui_bg
+5 ), 0 );
1979 rect_copy( inout_panel
, out_content_panel
);
1980 ui_rect_pad( out_content_panel
, (ui_px
[2]){ k_ui_padding
, k_ui_padding
} );
1983 for( i32 i
=0; i
<count
; i
++ ){
1985 bar
[0] + ((f32
)i
*width
),
1991 enum ui_scheme_colour colour
= k_ui_bg
+4;
1992 if( i
== cur_page
){
1994 ui_outline( button
, 1, ui_colour( k_ui_bg
+5 ),
1995 UI_TOP
|UI_LEFT
|UI_RIGHT
);
1999 if( ui_colourbutton_text( button
, titles
[i
], 1, colour
) == 1 )
2006 * -----------------------------------------------------------------------------
2008 static void ui_start_modal( const char *message
, u32 options
){
2009 vg_ui
.focused_control_type
= k_ui_control_modal
;
2010 vg_ui
.modal
.message
= message
;
2011 vg_ui
.modal
.callbacks
.close
= NULL
;
2012 vg_ui
.modal
.options
= options
;
2014 u32 type
= options
& UI_MODAL_TYPE_BITS
;
2015 if( type
== UI_MODAL_OK
) vg_info( message
);
2016 else if( type
== UI_MODAL_WARN
) vg_warn( message
);
2017 else if( type
== UI_MODAL_GOOD
) vg_success( message
);
2018 else if( type
== UI_MODAL_BAD
) vg_error( message
);
2023 * -----------------------------------------------------------------------------
2029 static void _ui_proc_key( SDL_Keysym ev
){
2030 if( vg_ui
.focused_control_type
!= k_ui_control_textbox
){
2034 struct textbox_mapping
{
2038 void (*handler
)(void);
2042 { 0, SDLK_LEFT
, _ui_textbox_left
},
2043 { KMOD_SHIFT
, SDLK_LEFT
, _ui_textbox_left_select
},
2044 { 0, SDLK_RIGHT
, _ui_textbox_right
},
2045 { KMOD_SHIFT
, SDLK_RIGHT
, _ui_textbox_right_select
},
2046 { 0, SDLK_DOWN
, _ui_textbox_down
},
2047 { 0, SDLK_UP
, _ui_textbox_up
},
2048 { 0, SDLK_BACKSPACE
, _ui_textbox_backspace
},
2049 { KMOD_SHIFT
, SDLK_BACKSPACE
, _ui_textbox_backspace
},
2050 { KMOD_CTRL
, SDLK_BACKSPACE
, _ui_textbox_backspace
},
2051 { 0, SDLK_DELETE
, _ui_textbox_delete
},
2052 { 0, SDLK_HOME
, _ui_textbox_home
},
2053 { KMOD_SHIFT
, SDLK_HOME
, _ui_textbox_home_select
},
2054 { 0, SDLK_END
, _ui_textbox_end
},
2055 { KMOD_SHIFT
, SDLK_END
, _ui_textbox_end_select
},
2056 { KMOD_CTRL
, SDLK_a
, _ui_textbox_select_all
},
2057 { KMOD_CTRL
, SDLK_c
, _ui_textbox_to_clipboard
},
2058 { KMOD_CTRL
, SDLK_x
, _ui_textbox_cut
},
2059 { KMOD_CTRL
, SDLK_v
, _ui_textbox_clipboard_paste
},
2060 { 0, SDLK_RETURN
, _ui_textbox_enter
},
2061 { 0, SDLK_ESCAPE
, ui_defocus_all
},
2066 if( ev
.mod
& KMOD_SHIFT
)
2069 if( ev
.mod
& KMOD_CTRL
)
2072 if( ev
.mod
& KMOD_ALT
)
2075 for( int i
=0; i
<vg_list_size( mappings
); i
++ ){
2076 struct textbox_mapping
*mapping
= &mappings
[i
];
2078 if( mapping
->key
== ev
.sym
){
2079 if( mapping
->mod
== 0 ){
2085 else if( (mod
& mapping
->mod
) == mapping
->mod
){
2094 * Callback for text entry mode
2096 static void ui_proc_utf8( const char *text
){
2097 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
2098 const char *ptr
= text
;
2101 if( *ptr
!= '`' ) _ui_textbox_put_char( *ptr
);
2105 if( vg_ui
.textbox
.callbacks
.change
){
2106 vg_ui
.textbox
.callbacks
.change( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
2113 * -----------------------------------------------------------------------------
2116 static void ui_dev_colourview(void){
2117 ui_rect window
= {vg
.window_x
-256,0,256,vg
.window_y
}, swatch
;
2119 const char *names
[vg_list_size(vg_ui
.scheme
)] = {
2120 [k_ui_bg
] = "k_ui_bg", "k_ui_bg+1", "k_ui_bg+2", "k_ui_bg+3",
2121 "k_ui_bg+4", "k_ui_bg+5", "k_ui_bg+6", "k_ui_bg+7",
2123 [k_ui_fg
] = "k_ui_fg", "k_ui_fg+1", "k_ui_fg+2", "k_ui_fg+3",
2124 "k_ui_fg+4", "k_ui_fg+5", "k_ui_fg+6", "k_ui_fg+7",
2126 [k_ui_red
] = "k_ui_red", "k_ui_orange", "k_ui_yellow", "k_ui_green",
2127 "k_ui_aqua", "k_ui_blue", "k_ui_purple", "k_ui_gray",
2128 "k_ui_red+8","k_ui_orange+8","k_ui_yellow+8","k_ui_green+8",
2129 "k_ui_aqua+8","k_ui_blue+8","k_ui_purple+8","k_ui_gray+8" };
2132 ui_split_ratio( window
, k_ui_axis_v
, 0.5f
, 0, col
[0], col
[1] );
2134 for( int i
=0; i
<vg_list_size(vg_ui
.scheme
); i
++ ){
2135 int which
= (i
/8)%2;
2137 ui_split( col
[which
], k_ui_axis_h
, 24, 0, swatch
, col
[which
] );
2138 ui_fill( swatch
, ui_colour(i
) );
2141 ui_text(swatch
, names
[i
], 1, k_ui_align_middle_left
, ui_colourcont(i
));
2145 #endif /* VG_IMGUI_H */