projects / vg.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
intermediate representation HSV
[vg.git] / vg_imgui.h
1 /* Copyright (C) 2021-2023 Harry Godden (hgn) - All Rights Reserved */
2
3 /*
4 * Principles:
5 *
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
10 * unique id
11 * 5. a maximum of ONE control per memory location can be drawn at any given
12 * point.
13 */
14
15 #ifndef VG_IMGUI_H
16 #define VG_IMGUI_H
17
18 #define VG_GAME
19 #include "vg/vg.h"
20 #include "vg/vg_tex.h"
21 #include "vg/vg_shader.h"
22
23 typedef i16 ui_px;
24 typedef ui_px ui_rect[4];
25 typedef ui_px ui_point[2];
26 typedef struct ui_vert ui_vert;
27
28 enum ui_axis {
29 k_ui_axis_h = 0x0u,
30 k_ui_axis_v = 0x1u,
31 };
32
33 /* Relative to cursor p0 */
34 enum ui_align
35 { /* DC BA */
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,
40
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,
45
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,
50 };
51
52 #pragma pack(push,1)
53 struct ui_vert
54 {
55 ui_px co[2];
56 u16 uv[2];
57 u32 colour;
58 };
59 #pragma pack(pop)
60
61 enum ui_scheme_colour{
62 k_ui_bg = 0,
63 k_ui_fg = 8,
64 k_ui_hue = 16,
65 k_ui_red = 16,
66 k_ui_orange,
67 k_ui_yellow,
68 k_ui_green,
69 k_ui_aqua,
70 k_ui_blue,
71 k_ui_purple,
72 k_ui_gray,
73 k_ui_brighter = 8
74 };
75
76 static ui_px k_ui_widget_height = 28,
77 k_ui_scale = 1,
78 k_ui_padding = 8;
79
80 typedef u32 ui_scheme[8*4];
81
82 struct ui_font {
83 ui_px glyph_width,
84 glyph_height,
85 glyph_baseline,
86 line_height,
87 sheet_size,
88 spacing,
89 offset_y;
90
91 u8 ascii_start;
92 };
93 typedef struct ui_font ui_font;
94
95 static const ui_font vg_ui_font_small = {
96 .glyph_width = 8,
97 .glyph_height = 14,
98 .glyph_baseline = 4,
99 .line_height = 14,
100 .sheet_size = 256,
101 .spacing = 8,
102 .ascii_start = ' ',
103 .offset_y = 0
104 },
105 vg_ui_font_big = {
106 .glyph_width = 12,
107 .glyph_height = 21,
108 .glyph_baseline = 6,
109 .line_height = 21,
110 .sheet_size = 256,
111 .spacing = 10,
112 .ascii_start = ' ',
113 .offset_y = 84
114 };
115
116 #define UI_RGB( STDHEX ) 0xff000000 |\
117 ((STDHEX&0x000000ff)<<16) |\
118 ((STDHEX&0x0000ff00) ) |\
119 ((STDHEX&0x00ff0000)>>16)
120
121 #define UI_TEXTBOX_MULTILINE 0x1
122 #define UI_TEXTBOX_WRAP 0x2
123 #define UI_TEXTBOX_AUTOFOCUS 0x4
124
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
130
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))
134
135 #define UI_TOP 0x1
136 #define UI_LEFT 0x2
137 #define UI_BOTTOM 0x4
138 #define UI_RIGHT 0x8
139
140 struct{
141 struct ui_vert *vertex_buffer;
142 u16 *indice_buffer;
143 u32 max_verts, max_indices,
144 cur_vert, cur_indice,
145 vert_start, indice_start;
146
147 union {
148 void *focused_control_id; /* uses the memory location of various locking
149 controls as an id */
150 char *textbuf;
151 i32 *ptr_enum;
152 };
153
154 u32 focused_control_hit;
155 enum ui_control_type{
156 k_ui_control_none,
157 k_ui_control_textbox,
158 k_ui_control_enum,
159 k_ui_control_modal
160 }
161 focused_control_type;
162
163 union{ /* controls that can be focused */
164 struct ui_textbuf{
165 int cursor_user, cursor_pos;
166 u32 len;
167 u32 flags;
168
169 struct ui_textbox_callbacks{
170 void (*enter)( char *, u32 ),
171 (*up)( char *, u32 ),
172 (*down)( char *, u32 ),
173 (*change)( char *, u32 ),
174 (*escape)( void );
175 }
176 callbacks;
177 }
178 textbox;
179
180 struct ui_enum{
181 struct ui_enum_opt{
182 i32 value;
183 const char *alias;
184 }
185 *options;
186 u32 option_count;
187 ui_rect rect;
188 }
189 _enum;
190 };
191
192 struct ui_modal{
193 const char *message;
194 u32 options;
195
196 struct ui_modal_callbacks{
197 void (*close)(u32);
198 }
199 callbacks;
200 }
201 modal;
202
203 GLuint tex_glyphs, vao, vbo, ebo, tex_bg;
204 v2f bg_inverse_ratio;
205
206 ui_px mouse[2], mouse_click[2];
207 u32 mouse_state[2];
208 u32 ignore_input_frames;
209 int wants_mouse;
210
211 ui_rect click_fader, click_fader_end;
212 float click_fade_opacity;
213 f32 frosting;
214
215 ui_scheme scheme;
216 const ui_font *font;
217
218 enum ui_cursor{
219 k_ui_cursor_default,
220 k_ui_cursor_ibeam,
221 k_ui_cursor_hand,
222 k_ui_cursor_max
223 }
224 cursor;
225
226 SDL_Cursor *cursor_map[ k_ui_cursor_max ];
227 v4f colour;
228
229 f32 hue; /* lol this sucks */
230 }
231 static vg_ui = {
232 .scheme = {
233 [ k_ui_bg+0 ] = UI_RGB( 0x1d2021 ),
234 [ k_ui_bg+1 ] = UI_RGB( 0x282828 ),
235 [ k_ui_bg+2 ] = UI_RGB( 0x3c3836 ),
236 [ k_ui_bg+3 ] = UI_RGB( 0x504945 ),
237 [ k_ui_bg+4 ] = UI_RGB( 0x665c54 ),
238 [ k_ui_bg+5 ] = UI_RGB( 0x7c6f64 ),
239 [ k_ui_bg+6 ] = UI_RGB( 0x928374 ),
240 [ k_ui_bg+7 ] = UI_RGB( 0xa89984 ),
241
242 [ k_ui_fg+0 ] = UI_RGB( 0xebdbb2 ),
243 [ k_ui_fg+1 ] = UI_RGB( 0xfbf1c7 ),
244 [ k_ui_fg+2 ] = UI_RGB( 0xd5c4a1 ),
245 [ k_ui_fg+3 ] = UI_RGB( 0xbdae93 ),
246 [ k_ui_fg+4 ] = UI_RGB( 0xa89984 ),
247 [ k_ui_fg+5 ] = UI_RGB( 0x000000 ),
248 [ k_ui_fg+6 ] = UI_RGB( 0x000000 ),
249 [ k_ui_fg+7 ] = UI_RGB( 0x000000 ),
250
251 [ k_ui_red ] = UI_RGB( 0xcc241d ),
252 [ k_ui_orange ] = UI_RGB( 0xd65d0e ),
253 [ k_ui_yellow ] = UI_RGB( 0xd79921 ),
254 [ k_ui_green ] = UI_RGB( 0x98971a ),
255 [ k_ui_aqua ] = UI_RGB( 0x689d6a ),
256 [ k_ui_blue ] = UI_RGB( 0x458588 ),
257 [ k_ui_purple ] = UI_RGB( 0xb16286 ),
258 [ k_ui_gray ] = UI_RGB( 0x928374 ),
259 [ k_ui_red + k_ui_brighter ] = UI_RGB( 0xfb4934 ),
260 [ k_ui_orange + k_ui_brighter ] = UI_RGB( 0xfe8019 ),
261 [ k_ui_yellow + k_ui_brighter ] = UI_RGB( 0xfabd2f ),
262 [ k_ui_green + k_ui_brighter ] = UI_RGB( 0xb8bb26 ),
263 [ k_ui_aqua + k_ui_brighter ] = UI_RGB( 0x8ec07c ),
264 [ k_ui_blue + k_ui_brighter ] = UI_RGB( 0x83a598 ),
265 [ k_ui_purple + k_ui_brighter ] = UI_RGB( 0xd3869b ),
266 [ k_ui_gray + k_ui_brighter ] = UI_RGB( 0xa89984 ),
267 },
268 .font = &vg_ui_font_small,
269 .colour = {1.0f,1.0f,1.0f,1.0f},
270 .bg_inverse_ratio = {1,1}
271 };
272
273 static struct vg_shader _shader_ui ={
274 .name = "[vg] ui - transparent",
275 .link = NULL,
276 .vs = {
277 .orig_file = NULL,
278 .static_src =
279 "layout (location=0) in vec2 a_co;"
280 "layout (location=1) in vec2 a_uv;"
281 "layout (location=2) in vec4 a_colour;"
282 "uniform mat3 uPv;"
283 "uniform vec2 uBGInverseRatio;"
284 ""
285 "out vec4 aTexCoords;"
286 "out vec4 aColour;"
287 ""
288 "void main(){"
289 "vec4 proj_pos = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
290 "gl_Position = proj_pos;"
291 "aTexCoords = vec4( a_uv * 0.00390625, "
292 " (proj_pos.xy*0.5+0.5) * uBGInverseRatio );"
293 "aColour = a_colour;"
294 "}",
295 },
296 .fs = {
297 .orig_file = NULL,
298 .static_src =
299 "uniform sampler2D uTexGlyphs;"
300 "uniform sampler2D uTexBG;"
301 "uniform vec4 uColour;"
302 "uniform float uSpread;"
303 "out vec4 FragColor;"
304 ""
305 "in vec4 aTexCoords;"
306 "in vec4 aColour;"
307 ""
308 "vec2 rand_hash22( vec2 p ){"
309 "vec3 p3 = fract(vec3(p.xyx) * 213.8976123);"
310 "p3 += dot(p3, p3.yzx+19.19);"
311 "return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));"
312 "}"
313 ""
314 "void main(){"
315 "vec4 diffuse = aColour;"
316
317 "vec4 avg = vec4(0.0);"
318
319 "if( aColour.a == 0.0 ){"
320 "avg = aColour;"
321 "avg.a = texture( uTexGlyphs, aTexCoords.xy ).r;"
322 "}"
323 "else{"
324 "if( uSpread > 0.0001 ){"
325 "for( int i=0; i<4; i ++ ){"
326 "vec2 spread = rand_hash22(aTexCoords.zw+vec2(float(i)));"
327 "avg += texture( uTexBG, aTexCoords.zw + (spread-0.5)*uSpread );"
328 "}"
329 "avg *= 0.25;"
330 "avg.a = 1.0;"
331 "avg.rgb = mix( avg.rgb, aColour.rgb, aColour.a );"
332 "}"
333 "else{"
334 "avg = aColour;"
335 "}"
336 "}"
337
338 "FragColor = avg * uColour;"
339 "}"
340 }
341 };
342
343 static struct vg_shader _shader_ui_image = {
344 .name = "[vg] ui_image",
345 .link = NULL,
346 .vs =
347 {
348 .orig_file = NULL,
349 .static_src =
350 "layout (location=0) in vec2 a_co;"
351 "layout (location=1) in vec2 a_uv;"
352 "layout (location=2) in vec4 a_colour;"
353 "uniform mat3 uPv;"
354
355 "out vec2 aTexCoords;"
356 "out vec4 aColour;"
357 "out vec2 aWsp;"
358
359 "void main()"
360 "{"
361 "gl_Position = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
362 "aTexCoords = a_uv * 0.00390625;"
363 "aColour = a_colour;"
364
365 "aWsp = a_co;"
366 "}",
367 },
368 .fs =
369 {
370 .orig_file = NULL,
371 .static_src =
372 "uniform sampler2D uTexImage;"
373 "uniform vec4 uColour;"
374 "out vec4 FragColor;"
375
376 "in vec2 aTexCoords;"
377 "in vec4 aColour;"
378 "in vec2 aWsp;"
379
380 "void main()"
381 "{"
382 "vec4 colour = texture( uTexImage, aTexCoords );"
383 "FragColor = colour * uColour;"
384 "}"
385 }
386 };
387
388 static struct vg_shader _shader_ui_hsv = {
389 .name = "[vg] ui_hsv",
390 .link = NULL,
391 .vs = {
392 .orig_file = NULL,
393 .static_src =
394 "layout (location=0) in vec2 a_co;"
395 "layout (location=1) in vec2 a_uv;"
396 "layout (location=2) in vec4 a_colour;"
397 "uniform mat3 uPv;"
398
399 "out vec2 aTexCoords;"
400 "out vec4 aColour;"
401 "out vec2 aWsp;"
402
403 "void main()"
404 "{"
405 "gl_Position = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
406 "aTexCoords = a_uv * 0.00390625;"
407 "aColour = a_colour;"
408
409 "aWsp = a_co;"
410 "}",
411 },
412 .fs =
413 {
414 .orig_file = NULL,
415 .static_src =
416 "uniform float uHue;"
417 "out vec4 FragColor;"
418
419 "in vec2 aTexCoords;"
420 "in vec4 aColour;"
421 "in vec2 aWsp;"
422
423 "void main()"
424 "{"
425 "vec3 c = vec3( uHue, aTexCoords );"
426 "vec4 K = vec4(1.0,2.0/3.0,1.0/3.0,3.0);"
427 "vec3 p = abs(fract(c.xxx+K.xyz)*6.0 - K.www);"
428 "vec3 colour = c.z*mix(K.xxx,clamp(p-K.xxx,0.0,1.0),c.y);"
429 "FragColor = vec4( colour, 1.0 );"
430 "}"
431 }
432 };
433
434 static void _vg_ui_init(void){
435 if( !vg_shader_compile( &_shader_ui ) ||
436 !vg_shader_compile( &_shader_ui_image ) ||
437 !vg_shader_compile( &_shader_ui_hsv ) ){
438 vg_fatal_error( "Failed to compile ui shader" );
439 }
440
441 /*
442 * Vertex buffer
443 * ----------------------------------------
444 */
445
446 vg_ui.max_indices = 20000;
447 vg_ui.max_verts = 30000;
448
449 /* Generate the buffer we are gonna be drawing to */
450 glGenVertexArrays( 1, &vg_ui.vao );
451 glGenBuffers( 1, &vg_ui.vbo );
452 glGenBuffers( 1, &vg_ui.ebo );
453
454 glBindVertexArray( vg_ui.vao );
455 glBindBuffer( GL_ARRAY_BUFFER, vg_ui.vbo );
456
457 glBufferData( GL_ARRAY_BUFFER,
458 vg_ui.max_verts * sizeof( struct ui_vert ),
459 NULL, GL_DYNAMIC_DRAW );
460 glBindVertexArray( vg_ui.vao );
461
462 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vg_ui.ebo );
463 glBufferData( GL_ELEMENT_ARRAY_BUFFER,
464 vg_ui.max_indices * sizeof( u16 ), NULL, GL_DYNAMIC_DRAW );
465
466 VG_CHECK_GL_ERR();
467
468 /* Set pointers */
469 u32 const stride = sizeof( struct ui_vert );
470
471 /* XY */
472 glVertexAttribPointer( 0, 2, GL_SHORT, GL_FALSE, stride,
473 (void *)offsetof( struct ui_vert, co ) );
474 glEnableVertexAttribArray( 0 );
475
476 /* UV */
477 glVertexAttribPointer( 1, 2, GL_UNSIGNED_SHORT, GL_FALSE, stride,
478 (void *)offsetof( struct ui_vert, uv ) );
479 glEnableVertexAttribArray( 1 );
480
481 /* COLOUR */
482 glVertexAttribPointer( 2, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride,
483 (void *)offsetof( struct ui_vert, colour ) );
484 glEnableVertexAttribArray( 2 );
485
486 VG_CHECK_GL_ERR();
487
488 /* Alloc RAM default context */
489 u32 vert_size = vg_ui.max_verts*sizeof(struct ui_vert),
490 inds_size = vg_align8( vg_ui.max_indices*sizeof(u16) );
491
492 vg_ui.vertex_buffer = vg_linear_alloc( vg_mem.rtmemory, vert_size );
493 vg_ui.indice_buffer = vg_linear_alloc( vg_mem.rtmemory, inds_size );
494
495 /* font
496 * -----------------------------------------------------
497 */
498
499 /* Load default font */
500 u32 compressed[] = {
501 #include "vg/vg_pxfont_thin.h"
502 };
503
504 u32 pixels = 0, total = 256*256, data = 0;
505 u8 image[256*256];
506
507 while( pixels < total ){
508 for( int b = 31; b >= 0; b-- ){
509 image[ pixels ++ ] = (compressed[data] & (0x1u << b))? 0xffu: 0x00u;
510
511 if( pixels >= total ){
512 total = 0;
513 break;
514 }
515 }
516 data++;
517 }
518
519 glGenTextures( 1, &vg_ui.tex_glyphs );
520 glBindTexture( GL_TEXTURE_2D, vg_ui.tex_glyphs );
521 glTexImage2D( GL_TEXTURE_2D, 0, GL_R8, 256, 256, 0,
522 GL_RED, GL_UNSIGNED_BYTE, image );
523
524 VG_CHECK_GL_ERR();
525 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
526 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
527 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
528 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
529
530 /*
531 * Cursors
532 * ---------------------------------------------------------------
533 */
534
535 vg_ui.cursor_map[ k_ui_cursor_default ] =
536 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_ARROW );
537 vg_ui.cursor_map[ k_ui_cursor_hand ] =
538 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_HAND );
539 vg_ui.cursor_map[ k_ui_cursor_ibeam ] =
540 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_IBEAM );
541 }
542
543 enum ui_shader {
544 k_ui_shader_colour,
545 k_ui_shader_image,
546 k_ui_shader_hsv,
547 };
548
549 static void rect_copy( ui_rect a, ui_rect b ){
550 for( int i=0; i<4; i++ )
551 b[i] = a[i];
552 }
553
554 static void ui_flush( enum ui_shader shader, f32 w, f32 h ){
555 u32 vertex_offset = vg_ui.vert_start*sizeof(ui_vert),
556 vertex_count = vg_ui.cur_vert-vg_ui.vert_start,
557 vertex_size = vertex_count*sizeof(ui_vert),
558
559 indice_offset = vg_ui.indice_start*sizeof(u16),
560 indice_count = vg_ui.cur_indice-vg_ui.indice_start,
561 indice_size = indice_count * sizeof(u16);
562
563 if( !vertex_size || !indice_size )
564 return;
565
566 glBindVertexArray( vg_ui.vao );
567 glBindBuffer( GL_ARRAY_BUFFER, vg_ui.vbo );
568 glBufferSubData( GL_ARRAY_BUFFER, vertex_offset, vertex_size,
569 vg_ui.vertex_buffer+vg_ui.vert_start );
570
571 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vg_ui.ebo );
572 glBufferSubData( GL_ELEMENT_ARRAY_BUFFER, indice_offset, indice_size,
573 vg_ui.indice_buffer+vg_ui.indice_start );
574
575 glDisable( GL_DEPTH_TEST );
576 glEnable( GL_BLEND );
577 glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
578 glBlendEquation( GL_FUNC_ADD );
579 glDisable( GL_CULL_FACE );
580
581 m3x3f view = M3X3_IDENTITY;
582 m3x3_translate( view, (v3f){ -1.0f, 1.0f, 0.0f } );
583 m3x3_scale( view, (v3f){ 1.0f/(w*0.5f),
584 -1.0f/(h*0.5f), 1.0f } );
585
586 if( shader == k_ui_shader_colour ){
587 glUseProgram( _shader_ui.id );
588
589 glUniformMatrix3fv( glGetUniformLocation( _shader_ui.id, "uPv" ), 1,
590 GL_FALSE, (float *)view );
591 glUniform4fv( glGetUniformLocation( _shader_ui.id, "uColour" ), 1,
592 vg_ui.colour );
593
594 glActiveTexture( GL_TEXTURE0 );
595 glBindTexture( GL_TEXTURE_2D, vg_ui.tex_glyphs );
596 glUniform1i( glGetUniformLocation( _shader_ui.id, "uTexGlyphs" ), 0 );
597
598 glActiveTexture( GL_TEXTURE1 );
599 glBindTexture( GL_TEXTURE_2D, vg_ui.tex_bg );
600 glUniform1i( glGetUniformLocation( _shader_ui.id, "uTexBG" ), 1 );
601 glUniform1f( glGetUniformLocation( _shader_ui.id, "uSpread" ),
602 vg_ui.frosting );
603 glUniform2fv( glGetUniformLocation( _shader_ui.id, "uBGInverseRatio" ),
604 1, vg_ui.bg_inverse_ratio );
605 }
606 else if( shader == k_ui_shader_image ){
607 glUseProgram( _shader_ui_image.id );
608 glUniformMatrix3fv( glGetUniformLocation( _shader_ui_image.id, "uPv" ), 1,
609 GL_FALSE, (float *)view );
610 glUniform1i( glGetUniformLocation(_shader_ui_image.id,"uTexImage"), 0 );
611 glUniform4fv( glGetUniformLocation( _shader_ui_image.id, "uColour" ), 1,
612 vg_ui.colour );
613 }
614 else if( shader == k_ui_shader_hsv ){
615 glUseProgram( _shader_ui_hsv.id );
616 glUniformMatrix3fv( glGetUniformLocation( _shader_ui_hsv.id, "uPv" ), 1,
617 GL_FALSE, (float *)view );
618 glUniform1f( glGetUniformLocation(_shader_ui_hsv.id,"uHue"), vg_ui.hue );
619 }
620 else
621 vg_fatal_error( "Invalid UI shader (%d)\n", shader );
622
623 glDrawElements( GL_TRIANGLES, indice_count, GL_UNSIGNED_SHORT,
624 (void *)(vg_ui.indice_start*sizeof(u16)) );
625
626 glDisable( GL_BLEND );
627
628 vg_ui.indice_start = vg_ui.cur_indice;
629 vg_ui.vert_start = vg_ui.cur_vert;
630 }
631
632 static void ui_fill_rect( ui_rect rect, u32 colour, ui_px uv[4] ){
633 /* this if far from ideal but stops us from crashing */
634 if( (vg_ui.cur_vert + 4 > vg_ui.max_verts) ||
635 (vg_ui.cur_indice + 6 > vg_ui.max_indices))
636 return;
637
638 struct ui_vert *vertices = &vg_ui.vertex_buffer[ vg_ui.cur_vert ];
639 u16 *indices = &vg_ui.indice_buffer[ vg_ui.cur_indice ];
640
641 for( int i=0; i<4; i++ ){
642 vertices[i].colour = colour;
643 }
644
645 vertices[0].co[0] = rect[0];
646 vertices[0].co[1] = rect[1];
647 vertices[0].uv[0] = uv[0];
648 vertices[0].uv[1] = uv[1];
649 vertices[1].co[0] = rect[0]+rect[2];
650 vertices[1].co[1] = rect[1];
651 vertices[1].uv[0] = uv[2];
652 vertices[1].uv[1] = uv[1];
653 vertices[2].co[0] = rect[0]+rect[2];
654 vertices[2].co[1] = rect[1]+rect[3];
655 vertices[2].uv[0] = uv[2];
656 vertices[2].uv[1] = uv[3];
657 vertices[3].co[0] = rect[0];
658 vertices[3].co[1] = rect[1]+rect[3];
659 vertices[3].uv[0] = uv[0];
660 vertices[3].uv[1] = uv[3];
661 u16 ind_start = vg_ui.cur_vert;
662
663 u16 start = vg_ui.cur_vert;
664 u32 mesh[] = { 0,2,1, 0,3,2 };
665
666 for( u32 i=0; i<vg_list_size(mesh); i++ ){
667 indices[i] = start+mesh[i];
668 }
669
670 vg_ui.cur_indice += 6;
671 vg_ui.cur_vert += 4;
672 }
673
674 static void ui_fill( ui_rect rect, u32 colour ){
675 ui_fill_rect( rect, colour, (ui_px[4]){ 4,4,4,4 } );
676 }
677
678 static void ui_outline( ui_rect rect, ui_px thickness, u32 colour, u32 mask ){
679 /* this if far from ideal but stops us from crashing */
680 if( (vg_ui.cur_vert + 8 > vg_ui.max_verts) ||
681 (vg_ui.cur_indice + 24 > vg_ui.max_indices))
682 return;
683
684 struct ui_vert *vertices = &vg_ui.vertex_buffer[ vg_ui.cur_vert ];
685 u16 *indices = &vg_ui.indice_buffer[ vg_ui.cur_indice ];
686
687 for( int i=0; i<8; i++ ){
688 vertices[i].uv[0] = 4;
689 vertices[i].uv[1] = 4;
690 vertices[i].colour = colour;
691 }
692
693 vertices[0].co[0] = rect[0];
694 vertices[0].co[1] = rect[1];
695 vertices[1].co[0] = rect[0]+rect[2];
696 vertices[1].co[1] = rect[1];
697 vertices[2].co[0] = rect[0]+rect[2];
698 vertices[2].co[1] = rect[1]+rect[3];
699 vertices[3].co[0] = rect[0];
700 vertices[3].co[1] = rect[1]+rect[3];
701 vertices[4].co[0] = vertices[0].co[0]-thickness;
702 vertices[4].co[1] = vertices[0].co[1]-thickness;
703 vertices[5].co[0] = vertices[1].co[0]+thickness;
704 vertices[5].co[1] = vertices[1].co[1]-thickness;
705 vertices[6].co[0] = vertices[2].co[0]+thickness;
706 vertices[6].co[1] = vertices[2].co[1]+thickness;
707 vertices[7].co[0] = vertices[3].co[0]-thickness;
708 vertices[7].co[1] = vertices[3].co[1]+thickness;
709
710 u16 start = vg_ui.cur_vert;
711 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 };
712
713 if( !mask )
714 mask = UI_TOP|UI_LEFT|UI_BOTTOM|UI_RIGHT;
715
716 u32 c = 0;
717 for( u32 i=0; i<vg_list_size(mesh)/6; i++ ){
718 if( (0x1<<i) & mask ){
719 for( u32 j=0; j<6; j++ )
720 indices[c ++] = start+mesh[i*6+j];
721 }
722 }
723
724 vg_ui.cur_indice += c;
725 vg_ui.cur_vert += 8;
726 }
727
728 static void ui_split( ui_rect rect,
729 enum ui_axis other, ui_px width, ui_px gap,
730 ui_rect l, ui_rect r ){
731 enum ui_axis dir = other ^ 0x1;
732
733 if( width < 0 ) width = rect[ 2+dir ] + width;
734
735 ui_rect temp;
736 rect_copy( rect, temp );
737
738 l[ dir ] = temp[ dir ];
739 r[ dir ] = temp[ dir ] + width + (gap/2);
740 l[ other ] = temp[ other ];
741 r[ other ] = temp[ other ];
742 l[ 2+dir ] = width - (gap/2);
743 r[ 2+dir ] = temp[ 2+dir ] - width - (gap/2);
744 l[ 2+other ] = temp[ 2+other ];
745 r[ 2+other ] = temp[ 2+other ];
746 }
747
748 static ui_px ui_text_line_width( const char *str );
749
750 static void ui_rect_center( ui_rect parent, ui_rect rect ){
751 rect[0] = parent[0] + (parent[2]-rect[2])/2;
752 rect[1] = parent[1] + (parent[3]-rect[3])/2;
753 }
754
755 static void ui_fit_item( ui_rect rect, ui_px size[2], ui_rect d ){
756 i32 rp = (i32)rect[2] * (i32)size[1],
757 rc = (i32)size[0] * (i32)rect[3];
758
759 enum ui_axis dir, other;
760 if( rc > rp ) dir = k_ui_axis_h;
761 else dir = k_ui_axis_v;
762 other = dir ^ 0x1;
763
764 d[2+dir] = rect[2+dir];
765 d[2+other] = (rect[2+dir] * size[other]) / size[dir];
766
767 ui_rect_center( rect, d );
768 }
769
770 static void ui_split_ratio( ui_rect rect, enum ui_axis dir, float ratio,
771 ui_px gap, ui_rect l, ui_rect r ){
772 ui_px width = (float)rect[ 2+(dir^0x1) ] * ratio;
773 ui_split( rect, dir, width, gap, l, r );
774 }
775
776 static void ui_rect_pad( ui_rect rect, ui_px pad[2] ){
777 rect[0] += pad[0];
778 rect[1] += pad[1];
779 rect[2] -= pad[0]*2;
780 rect[3] -= pad[1]*2;
781 }
782
783 static ui_px ui_text_line_width( const char *str ){
784 int length = 0;
785 const char *_c = str;
786 u8 c;
787
788 while( (c = *(_c ++)) ){
789 if( c >= 32 ) length ++;
790 else if( c == '\n' ) break;
791 }
792
793 return length * vg_ui.font->spacing;
794 }
795
796 static ui_px ui_text_string_height( const char *str ){
797 int height = 1;
798 const char *_c = str;
799 u8 c;
800
801 while( (c = *(_c ++)) ){
802 if( c == '\n' ) height ++;
803 }
804
805 return height * 14;
806 }
807
808 static ui_px ui_text_aligned_x( const char *str, ui_rect rect, ui_px scale,
809 enum ui_align align ){
810 enum ui_align lwr = k_ui_align_lwr & align;
811 if( lwr == k_ui_align_left ){
812 return rect[0];
813 }
814 else{
815 ui_px width = ui_text_line_width( str ) * scale;
816
817 if( lwr == k_ui_align_right )
818 return rect[0] + rect[2]-width;
819 else
820 return rect[0] + (rect[2]-width)/2;
821 }
822 }
823
824 static ui_px ui_min( ui_px a, ui_px b ){ return a<b?a:b; }
825 static ui_px ui_max( ui_px a, ui_px b ){ return a>b?a:b; }
826 static ui_px ui_clamp( ui_px a, ui_px min, ui_px max ){
827 return ui_min( max, ui_max( a, min ) );
828 }
829
830 static int ui_clip( ui_rect parent, ui_rect child, ui_rect clipped ){
831 ui_px parent_max[2], child_max[2];
832 parent_max[0] = parent[0]+parent[2];
833 parent_max[1] = parent[1]+parent[3];
834 child_max[0] = child[0]+child[2];
835 child_max[1] = child[1]+child[3];
836
837 clipped[0] = ui_clamp( child[0], parent[0], parent_max[0] );
838 clipped[1] = ui_clamp( child[1], parent[1], parent_max[1] );
839 clipped[2] = ui_clamp( child_max[0], parent[0], parent_max[0] );
840 clipped[3] = ui_clamp( child_max[1], parent[1], parent_max[1] );
841
842 if( clipped[0] == clipped[2] ||
843 clipped[1] == clipped[3] )
844 return 0;
845
846 clipped[2] -= clipped[0];
847 clipped[3] -= clipped[1];
848
849 return 1;
850 }
851
852 static int ui_inside_rect( ui_rect rect, ui_px co[2] ){
853 if( co[0] >= rect[0] &&
854 co[1] >= rect[1] &&
855 co[0] < rect[0]+rect[2] &&
856 co[1] < rect[1]+rect[3] ){
857 return 1;
858 }
859 else
860 return 0;
861 }
862
863 static int ui_click_down( u32 mask ){
864 if( vg_ui.ignore_input_frames ) return 0;
865 if( (vg_ui.mouse_state[0] & mask) &&
866 !(vg_ui.mouse_state[1] & mask) )
867 return 1;
868 else
869 return 0;
870 }
871
872 static int ui_clicking( u32 mask ){
873 if( vg_ui.ignore_input_frames ) return 0;
874 return vg_ui.mouse_state[0] & mask;
875 }
876
877 static int ui_click_up( u32 mask ){
878 if( vg_ui.ignore_input_frames ) return 0;
879 if( (vg_ui.mouse_state[1] & mask) &&
880 !(vg_ui.mouse_state[0] & mask) )
881 return 1;
882 else
883 return 0;
884 }
885
886 static void ui_prerender(void){
887 int x, y;
888 vg_ui.mouse_state[1] = vg_ui.mouse_state[0];
889 vg_ui.mouse_state[0] = SDL_GetMouseState( &x, &y );
890 vg_ui.mouse[0] = x;
891 vg_ui.mouse[1] = y;
892
893 vg_ui.cur_vert = 0;
894 vg_ui.cur_indice = 0;
895 vg_ui.vert_start = 0;
896 vg_ui.indice_start = 0;
897 vg_ui.focused_control_hit = 0;
898 vg_ui.cursor = k_ui_cursor_default;
899 vg_ui.wants_mouse = 0;
900
901 if( vg_ui.ignore_input_frames ){
902 vg_ui.ignore_input_frames --;
903 return;
904 }
905
906 if( ui_click_down(UI_MOUSE_LEFT)||ui_click_down(UI_MOUSE_MIDDLE) ){
907 vg_ui.mouse_click[0] = vg_ui.mouse[0];
908 vg_ui.mouse_click[1] = vg_ui.mouse[1];
909 }
910 }
911
912 static u32 ui_colour( enum ui_scheme_colour id ){
913 return vg_ui.scheme[ id ];
914 }
915
916 /* get an appropriately contrasting colour given the base */
917 static u32 ui_colourcont( enum ui_scheme_colour id ){
918 if ( id < k_ui_bg+6 ) return ui_colour( k_ui_fg );
919 else if( id < k_ui_fg ) return ui_colour( k_ui_bg+1 );
920 else if( id < k_ui_hue ) return ui_colour( k_ui_bg+3 );
921 else if( id < k_ui_red+k_ui_brighter ) return ui_colour( k_ui_fg );
922 else return ui_colour( k_ui_fg+1 );
923 }
924
925 static void ui_hex_to_norm( u32 hex, v4f norm ){
926 norm[0] = ((hex ) & 0xff);
927 norm[1] = ((hex>>8 ) & 0xff);
928 norm[2] = ((hex>>16) & 0xff);
929 norm[3] = ((hex>>24) & 0xff);
930 v4_muls( norm, 1.0f/255.0f, norm );
931 }
932
933 static void ui_text_glyph( const struct ui_font *font, ui_px scale,
934 u8 glyph, ui_rect out_texcoords ){
935 glyph -= font->ascii_start;
936
937 ui_px per_row = font->sheet_size / font->glyph_width,
938 column = (ui_px)glyph % per_row,
939 row = (glyph - column) / per_row;
940
941 out_texcoords[0] = column * font->glyph_width;
942 out_texcoords[1] = row * font->glyph_height + font->offset_y;
943 out_texcoords[2] = out_texcoords[0] + font->glyph_width;
944 out_texcoords[3] = out_texcoords[1] + font->glyph_height;
945 }
946
947 static u32 ui_opacity( u32 colour, f32 opacity ){
948 u32 alpha = opacity * 255.0f;
949 return (colour & 0x00ffffff) | (alpha << 24);
950 }
951
952 static u32 ui_ntext( ui_rect rect, const char *str, u32 len, ui_px scale,
953 enum ui_align align, u32 colour ){
954 ui_rect text_cursor;
955 if( colour == 0 ) colour = ui_colour( k_ui_fg );
956
957 colour &= 0x00ffffff;
958
959 const char *_c = str;
960 u8 c;
961
962 text_cursor[0] = ui_text_aligned_x( str, rect, scale, align );
963 text_cursor[1] = rect[1];
964 text_cursor[2] = vg_ui.font->glyph_width*scale;
965 text_cursor[3] = vg_ui.font->glyph_height*scale;
966
967 u32 printed_chars = 0;
968
969 if( align & (k_ui_align_middle|k_ui_align_bottom) ){
970 ui_px height = ui_text_string_height( str ) * scale;
971
972 if( align & k_ui_align_bottom )
973 text_cursor[1] += rect[3]-height;
974 else
975 text_cursor[1] += (rect[3]-height)/2;
976 }
977
978 while( (c = *(_c ++)) ){
979 if( printed_chars >= len ){
980 printed_chars = 0;
981 text_cursor[1] += vg_ui.font->line_height*scale;
982 text_cursor[0] = ui_text_aligned_x( _c, rect, scale, align );
983 text_cursor[0] -= vg_ui.font->spacing*scale;
984
985 ui_rect glyph;
986 ui_text_glyph( vg_ui.font, scale, '\xb6' /*FIXME*/, glyph );
987 ui_fill_rect( text_cursor, 0x00ffffff, glyph );
988 text_cursor[0] += vg_ui.font->spacing*scale;
989 }
990
991 if( c == '\n' ){
992 text_cursor[1] += vg_ui.font->line_height*scale;
993 text_cursor[0] = ui_text_aligned_x( _c, rect, scale, align );
994 printed_chars = 0;
995 continue;
996 }
997 else if( c >= 33 ){
998 ui_rect glyph;
999 ui_text_glyph( vg_ui.font, scale, c, glyph );
1000
1001 ui_rect cursor_clipped;
1002 if( ui_clip( rect, text_cursor, cursor_clipped ) ){
1003 ui_fill_rect( cursor_clipped, colour, glyph );
1004 }
1005 }
1006 else if( c == '\x1B' ){
1007 /* vt codes */
1008 _c ++;
1009 u16 colour_id = 0;
1010 for( int i=0; i<3; i ++ ){
1011 if( _c[i] ){
1012 if( _c[i] == 'm' ){
1013 _c = _c + i + 1;
1014
1015 switch( colour_id ){
1016 case '0': colour = ui_colour( k_ui_fg ); break;
1017 case '3'|'0'<<8: colour = ui_colour( k_ui_bg ); break;
1018 case '3'|'1'<<8: colour = ui_colour( k_ui_red ); break;
1019 case '3'|'2'<<8: colour = ui_colour( k_ui_green ); break;
1020 case '3'|'3'<<8: colour = ui_colour( k_ui_yellow ); break;
1021 case '3'|'4'<<8: colour = ui_colour( k_ui_blue ); break;
1022 case '3'|'5'<<8: colour = ui_colour( k_ui_purple ); break;
1023 case '3'|'6'<<8: colour = ui_colour( k_ui_aqua ); break;
1024 case '3'|'7'<<8: colour = 0xffffffff; break;
1025 }
1026
1027 colour &= 0x00ffffff;
1028 break;
1029 }
1030
1031 colour_id |= _c[i] << (i*8);
1032 }
1033 else{
1034 _c = _c +i;
1035 break;
1036 }
1037 }
1038
1039 continue;
1040 }
1041 else if( c == '\t' ){
1042 text_cursor[0] += vg_ui.font->spacing*scale*4;
1043 printed_chars += 4;
1044 continue;
1045 }
1046
1047 text_cursor[0] += vg_ui.font->spacing*scale;
1048 printed_chars ++;
1049 }
1050
1051 return printed_chars;
1052 }
1053
1054 static void ui_text( ui_rect rect, const char *str, ui_px scale,
1055 enum ui_align align, u32 colour ){
1056 ui_ntext( rect, str, 1024, scale, align, colour );
1057 }
1058
1059 /*
1060 * Standard layout stuff
1061 * -----------------------------------------------------------------------------
1062 */
1063
1064 static void ui_panel( ui_rect in_rect, ui_rect out_panel ){
1065 ui_fill( in_rect, ui_colour( k_ui_bg+1 ) );
1066 ui_outline( in_rect, 1, ui_colour( k_ui_bg+7 ), 0 );
1067 rect_copy( in_rect, out_panel );
1068 ui_rect_pad( out_panel, (ui_px[2]){ k_ui_padding, k_ui_padding } );
1069 }
1070
1071 static void ui_label( ui_rect rect, const char *text, ui_px size,
1072 ui_px gap, ui_rect r ){
1073 ui_rect l;
1074 ui_px width = (ui_text_line_width(text)+vg_ui.font->spacing) * size;
1075 ui_split( rect, k_ui_axis_v, width, gap, l, r );
1076 ui_text( l, text, 1, k_ui_align_middle_left, 0 );
1077 }
1078
1079 static void ui_standard_widget( ui_rect inout_panel, ui_rect out_rect,
1080 ui_px count ){
1081 ui_px height = (count * vg_ui.font->glyph_height + 18) * k_ui_scale;
1082 ui_split( inout_panel, k_ui_axis_h, height, k_ui_padding,
1083 out_rect, inout_panel );
1084 }
1085
1086 static void ui_info( ui_rect inout_panel, const char *text ){
1087 ui_rect box;
1088 ui_standard_widget( inout_panel, box, 1 );
1089 ui_text( box, text, 1, k_ui_align_middle_left, 0 );
1090 }
1091
1092 static void ui_image( ui_rect rect, GLuint image ){
1093 ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y );
1094 glActiveTexture( GL_TEXTURE0 );
1095 glBindTexture( GL_TEXTURE_2D, image );
1096 ui_fill_rect( rect, 0xffffffff, (ui_px[4]){ 0,256,256,0 } );
1097 ui_flush( k_ui_shader_image, vg.window_x, vg.window_y );
1098 }
1099
1100 static u32 v4f_u32_colour( v4f colour ){
1101 u32 r = colour[0] * 255.0f,
1102 g = colour[1] * 255.0f,
1103 b = colour[2] * 255.0f,
1104 a = colour[3] * 255.0f;
1105
1106 return r | (g<<8) | (b<<16) | (a<<24);
1107 }
1108
1109 static void ui_defocus_all(void){
1110 if( vg_ui.focused_control_type == k_ui_control_textbox ){
1111 SDL_StopTextInput();
1112 if( vg_ui.textbox.callbacks.escape )
1113 vg_ui.textbox.callbacks.escape();
1114 }
1115
1116 vg_ui.focused_control_id = NULL;
1117 vg_ui.focused_control_hit = 0;
1118 vg_ui.focused_control_type = k_ui_control_none;
1119 }
1120
1121 enum ui_button_state {
1122 k_ui_button_none = 0x0,
1123 k_ui_button_click = 0x1,
1124 k_ui_button_holding_inside = 0x2,
1125 k_ui_button_holding_outside = 0x4,
1126 k_ui_button_hover = 0x8
1127 };
1128
1129 /* TODO: split this out into a formatless button and one that auto fills */
1130 static enum ui_button_state ui_colourbutton( ui_rect rect,
1131 enum ui_scheme_colour colour,
1132 enum ui_scheme_colour hover_colour,
1133 enum ui_scheme_colour hi_colour,
1134 bool const fill ){
1135 int clickup= ui_click_up(UI_MOUSE_LEFT),
1136 click = ui_clicking(UI_MOUSE_LEFT) | clickup,
1137 target = ui_inside_rect( rect, vg_ui.mouse_click ) && click,
1138 hover = ui_inside_rect( rect, vg_ui.mouse );
1139
1140 u32 col_base = vg_ui.scheme[ colour ],
1141 col_highlight = vg_ui.scheme[ hi_colour? hi_colour: k_ui_fg ],
1142 col_hover = vg_ui.scheme[ hover_colour? hover_colour:
1143 colour + k_ui_brighter ];
1144
1145 if( vg_ui.focused_control_type != k_ui_control_none ){
1146 clickup = 0;
1147 click = 0;
1148 target = 0;
1149 hover = 0;
1150 }
1151
1152 if( hover ){
1153 vg_ui.cursor = k_ui_cursor_hand;
1154 }
1155
1156 if( click ){
1157 if( target ){
1158 if( hover ){
1159 if( clickup ){
1160 vg_ui.ignore_input_frames = 2;
1161 ui_defocus_all();
1162
1163 if( fill ) {
1164 ui_fill( rect, col_highlight );
1165 rect_copy( rect, vg_ui.click_fader );
1166 rect_copy( rect, vg_ui.click_fader_end );
1167 vg_ui.click_fader_end[3] = 0;
1168 ui_rect_center( rect, vg_ui.click_fader_end );
1169 vg_ui.click_fade_opacity = 1.0f;
1170 }
1171
1172 return k_ui_button_click;
1173 }
1174 else{
1175 if( fill ) ui_fill( rect, col_highlight );
1176 return k_ui_button_holding_inside;
1177 }
1178 }
1179 else{
1180 if( fill ) ui_fill( rect, col_base );
1181 ui_outline( rect, 1, col_highlight, 0 );
1182 return k_ui_button_holding_outside;
1183 }
1184 }
1185 else{
1186 if( fill ) ui_fill( rect, col_base );
1187 return k_ui_button_none;
1188 }
1189 }
1190 else{
1191 if( hover ){
1192 if( fill ) ui_fill( rect, col_hover );
1193 return k_ui_button_hover;
1194 }
1195 else{
1196 if( fill ) ui_fill( rect, col_base );
1197 return k_ui_button_none;
1198 }
1199 }
1200 }
1201
1202 static enum ui_button_state ui_colourbutton_text(
1203 ui_rect rect, const char *string, ui_px scale,
1204 enum ui_scheme_colour colour ){
1205 enum ui_button_state state = ui_colourbutton( rect, colour, 0, 0, 1 );
1206 ui_rect t = { 0,0, ui_text_line_width( string )*scale, 14*scale };
1207 ui_rect_center( rect, t );
1208
1209 u32 text_colour = ui_colourcont(colour);
1210 if( state == k_ui_button_holding_inside )
1211 text_colour = colour;
1212
1213 ui_text( t, string, scale, k_ui_align_left, text_colour );
1214 return state;
1215 }
1216
1217 static enum ui_button_state ui_button_text( ui_rect rect,
1218 const char *string, ui_px scale ){
1219 return ui_colourbutton_text( rect, string, scale, k_ui_bg+4 );
1220 }
1221
1222 static enum ui_button_state ui_button( ui_rect inout_panel,
1223 const char *string ){
1224 ui_rect rect;
1225 ui_standard_widget( inout_panel, rect, 1 );
1226 return ui_colourbutton_text( rect, string, 1, k_ui_bg+4 );
1227 }
1228
1229 static void ui_enum_post(void);
1230 static void ui_postrender(void){
1231 if( vg_ui.click_fade_opacity > 0.0f ){
1232 float scale = vg_ui.click_fade_opacity;
1233 scale = vg_maxf( 1.0f/255.0f, scale*scale );
1234
1235 vg_ui.click_fade_opacity -= vg.time_frame_delta * 3.8f;
1236 u32 colour = (0x00ffffff & ui_colour(k_ui_fg))|0x7f000000;
1237
1238 v4f begin, end, dest;
1239 for( int i=0; i<4; i++ ){
1240 begin[i] = vg_ui.click_fader[i];
1241 end[i] = vg_ui.click_fader_end[i]+1;
1242 }
1243
1244 v4_lerp( end, begin, scale, dest );
1245
1246 ui_rect rect;
1247 for( int i=0; i<4; i++ ){
1248 rect[i] = dest[i];
1249 }
1250
1251 ui_fill( rect, colour );
1252 }
1253
1254 if( vg_ui.focused_control_type == k_ui_control_enum ){
1255 ui_enum_post();
1256 }
1257 else if( vg_ui.focused_control_type == k_ui_control_modal ){
1258 ui_rect screen = {0,0,vg.window_x,vg.window_y};
1259 ui_fill( screen, 0xa0000000 );
1260 ui_rect box = {0,0,400,200};
1261
1262 u32 colour = ui_colour(k_ui_fg),
1263 type = vg_ui.modal.options & UI_MODAL_TYPE_BITS;
1264 if ( type == 1 ) colour = ui_colour(k_ui_green);
1265 else if( type == 2 ) colour = ui_colour(k_ui_red);
1266 else if( type == 3 ) colour = ui_colour(k_ui_yellow);
1267
1268 ui_rect_center( screen, box );
1269 ui_fill( box, ui_colour(k_ui_bg) );
1270 ui_outline( box, -1, colour, 0 );
1271
1272 ui_rect message;
1273 rect_copy( box, message );
1274 message[3] = 100;
1275 ui_rect_center( box, message );
1276
1277 ui_rect row0, row1, btn;
1278 ui_split_ratio( message, k_ui_axis_h, 0.5f, 0, row0, row1 );
1279 row0[0] += vg_ui.font->spacing;
1280 ui_ntext( row0, vg_ui.modal.message, (box[2]/vg_ui.font->spacing)-2, 1,
1281 k_ui_align_left, colour );
1282
1283 rect_copy( row1, btn );
1284 btn[2] = 86;
1285 btn[3] = 28;
1286 ui_rect_center( row1, btn );
1287
1288 vg_ui.focused_control_type = k_ui_control_none; /* HACK */
1289 if( ui_button_text( btn, "OK", 1 ) != 1 )
1290 vg_ui.focused_control_hit = 1;
1291 vg_ui.focused_control_type = k_ui_control_modal; /* HACK */
1292 vg_ui.wants_mouse = 1;
1293 }
1294
1295 ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y );
1296
1297 if( !vg_ui.focused_control_hit ){
1298 ui_defocus_all();
1299 }
1300
1301 if( vg_ui.wants_mouse ){
1302 SDL_SetWindowGrab( vg.window, SDL_FALSE );
1303 SDL_SetRelativeMouseMode( SDL_FALSE );
1304 }
1305 else{
1306 SDL_SetWindowGrab( vg.window, SDL_TRUE );
1307 SDL_SetRelativeMouseMode( SDL_TRUE );
1308 }
1309
1310 SDL_SetCursor( vg_ui.cursor_map[ vg_ui.cursor ] );
1311 SDL_ShowCursor(1);
1312 }
1313
1314 /*
1315 * checkbox
1316 * -----------------------------------------------------------------------------
1317 */
1318
1319 static int ui_checkbox( ui_rect inout_panel, const char *str_label, i32 *data ){
1320 ui_rect rect, label, box;
1321 ui_standard_widget( inout_panel, rect, 1 );
1322
1323 ui_split( rect, k_ui_axis_v, -rect[3], 0, label, box );
1324 ui_text( label, str_label, k_ui_scale, k_ui_align_middle_left, 0 );
1325
1326 int changed = ui_colourbutton( box, k_ui_bg, 0, 0, 1 )==1;
1327 if( changed )
1328 *data = (*data) ^ 0x1;
1329
1330 if( *data ){
1331 ui_rect_pad( box, (ui_px[2]){4,4} );
1332 ui_fill( box, ui_colour( k_ui_orange ) );
1333 }
1334
1335 return changed;
1336 }
1337
1338 /*
1339 * Dropdown / Enum
1340 * -----------------------------------------------------------------------------
1341 */
1342
1343 /*
1344 * unfortunately no return value since we only find out that event in the
1345 * postrender step.
1346 */
1347 static void ui_enum( ui_rect inout_panel, const char *str_label,
1348 struct ui_enum_opt *options, u32 len, i32 *value ){
1349 ui_rect rect, label, box;
1350 ui_standard_widget( inout_panel, rect, 1 );
1351 ui_label( rect, str_label, k_ui_scale, 0, box );
1352
1353 const char *display = "OUT OF RANGE";
1354 int valid = 0;
1355 for( u32 i=0; i<len; i ++ ){
1356 if( *value == options[i].value ){
1357 display = options[i].alias;
1358 valid = 1;
1359 break;
1360 }
1361 }
1362
1363 if( ui_button_text( box, display, k_ui_scale ) == 1 ){
1364 vg_ui.focused_control_type = k_ui_control_enum;
1365 vg_ui.ptr_enum = value;
1366 vg_ui._enum.option_count = len;
1367 vg_ui._enum.options = options;
1368 rect_copy( box, vg_ui._enum.rect );
1369 }
1370
1371 if( !valid )
1372 ui_outline( box, 1, ui_colour(k_ui_red), 0 );
1373 }
1374
1375 static void ui_enum_post(void){
1376 ui_rect drawer;
1377 rect_copy( vg_ui._enum.rect, drawer );
1378 drawer[3] *= vg_ui._enum.option_count;
1379
1380 int close = 0;
1381 int clickany= ui_click_up(UI_MOUSE_LEFT|UI_MOUSE_RIGHT|UI_MOUSE_MIDDLE),
1382 hover = ui_inside_rect( drawer, vg_ui.mouse );
1383
1384 if( clickany && !hover ){
1385 return;
1386 }
1387
1388 /* HACK */
1389 vg_ui.focused_control_type = k_ui_control_none;
1390 i32 *value = vg_ui.ptr_enum;
1391
1392 for( u32 i=0; i<vg_ui._enum.option_count; i++ ){
1393 ui_rect button;
1394 ui_split( drawer, k_ui_axis_h, vg_ui._enum.rect[3], 0, button,drawer );
1395
1396 enum ui_scheme_colour colour = k_ui_bg+3;
1397 if( vg_ui._enum.options[i].value == *value )
1398 colour = k_ui_orange;
1399
1400 if( ui_colourbutton_text( button, vg_ui._enum.options[i].alias,
1401 k_ui_scale, colour ) == 1 ){
1402 *value = vg_ui._enum.options[i].value;
1403 close = 1;
1404 }
1405 }
1406
1407 /* HACK */
1408 vg_ui.focused_control_type = k_ui_control_enum;
1409
1410 if( !close )
1411 vg_ui.focused_control_hit = 1;
1412 }
1413
1414 /*
1415 * Slider
1416 * -----------------------------------------------------------------------------
1417 */
1418
1419 static enum ui_button_state _ui_slider( ui_rect box,
1420 f32 min, f32 max, f32 *value, const char *format ){
1421 f32 t;
1422
1423 enum ui_button_state
1424 mask_using =
1425 k_ui_button_holding_inside |
1426 k_ui_button_holding_outside |
1427 k_ui_button_click,
1428 mask_brighter =
1429 mask_using | k_ui_button_hover,
1430 state = ui_colourbutton( box, k_ui_bg, k_ui_bg+2, k_ui_bg+3, 1 );
1431
1432 if( state & mask_using ){
1433 t = vg_clampf( (f32)(vg_ui.mouse[0] - box[0]) / (f32)( box[2] ),
1434 0.0f, 1.0f );
1435 *value = vg_lerpf( min, max, t );
1436 }
1437 else
1438 t = vg_clampf( (*value - min) / (max-min), 0.0f, 1.0f );
1439
1440 ui_rect line = { box[0], box[1], t * (f32)box[2], box[3] };
1441 ui_fill( line, ui_colour(state&mask_brighter? k_ui_bg+4: k_ui_bg+2) );
1442
1443 ui_outline( box, 1, ui_colour(state? k_ui_fg+3: k_ui_bg+3), 0 );
1444
1445 /* TODO: replace this one day with our own function */
1446 char buf[32];
1447 snprintf( buf, sizeof(buf), format? format: "%.2f", *value );
1448 ui_text( box, buf, 1, k_ui_align_middle_center, 0 );
1449
1450 return state;
1451 }
1452
1453 static void ui_slider( ui_rect inout_panel, const char *str_label,
1454 f32 min, f32 max, f32 *value, const char *format ){
1455 ui_rect rect, label, box;
1456 ui_standard_widget( inout_panel, rect, 1 );
1457 ui_label( rect, str_label, k_ui_scale, 0, box );
1458 _ui_slider( box, min, max, value, format );
1459 }
1460
1461 /*
1462 * Colour picker
1463 * -----------------------------------------------------------------------------
1464 */
1465
1466 static void ui_colourpicker( ui_rect inout_panel, const char *str_label,
1467 v4f value ){
1468 ui_rect widget, left, right;
1469 ui_standard_widget( inout_panel, widget, 8 );
1470 ui_split_ratio( widget, k_ui_axis_v, 0.5f, 8, left, right );
1471
1472 ui_rect sliders[4];
1473 ui_split_ratio( right, k_ui_axis_h, 0.5f, 2, sliders[0], sliders[2] );
1474 ui_split_ratio( sliders[0], k_ui_axis_h, 0.5f, 2, sliders[0], sliders[1] );
1475 ui_split_ratio( sliders[2], k_ui_axis_h, 0.5f, 2, sliders[2], sliders[3] );
1476
1477 v4f hsv;
1478 vg_rgb_hsv( value, hsv );
1479
1480 enum ui_button_state modified = 0x00;
1481
1482 for( u32 i=0; i<4; i ++ ){
1483 modified |= _ui_slider( sliders[i], 0.0f, 1.0f, hsv+i,
1484 (const char *[]){ "hue %.2f",
1485 "sat %.2f",
1486 "lum %.2f",
1487 "alpha %.2f" }[i] );
1488 }
1489
1490 ui_rect preview, square;
1491 ui_split_ratio( left, k_ui_axis_v, 0.8f, 8, square, preview );
1492
1493 u32 state = ui_colourbutton( square, 0, 0, 0, 0 );
1494 modified |= state;
1495
1496 enum ui_button_state
1497 mask_using =
1498 k_ui_button_holding_inside |
1499 k_ui_button_holding_outside |
1500 k_ui_button_click;
1501
1502 if( state & mask_using ){
1503 for( u32 i=0; i<2; i ++ ){
1504 hsv[1+i] = vg_clampf(
1505 (f32)(vg_ui.mouse[i] - square[i]) / (f32)(square[2+i]),
1506 0.0f, 1.0f );
1507 }
1508
1509 hsv[2] = 1.0f-hsv[2];
1510 }
1511
1512 if( modified & (k_ui_button_click|k_ui_button_holding_inside|
1513 k_ui_button_holding_outside) ){
1514 vg_hsv_rgb( hsv, value );
1515 }
1516
1517 ui_outline( square, 1, ui_colour( state? k_ui_fg+3: k_ui_bg+3 ), 0 );
1518
1519 /* preview colour */
1520 v4f colour;
1521 vg_hsv_rgb( hsv, colour );
1522 colour[3] = 1.0f;
1523 ui_fill( preview, v4f_u32_colour( colour ) );
1524
1525 /* Draw hsv shader thingy */
1526 ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y );
1527 ui_fill_rect( square, 0xffffffff, (ui_px[4]){ 0,256,256,0 } );
1528 vg_ui.hue = hsv[0];
1529 ui_flush( k_ui_shader_hsv, vg.window_x, vg.window_y );
1530
1531 ui_rect marker = { square[0] + hsv[1] * (f32)square[2] - 4,
1532 square[1] + (1.0f-hsv[2]) * (f32)square[3] - 4,
1533 8, 8 },
1534 lx = { square[0],
1535 square[1] + (1.0f-hsv[2]) * (f32)square[3],
1536 square[2], 1 },
1537 ly = { square[0] + hsv[1] * (f32)square[2],
1538 square[1],
1539 1, square[3] };
1540
1541 ui_fill( marker, ui_colour( k_ui_fg ) );
1542 ui_fill( lx, ui_colour( k_ui_fg ) );
1543 ui_fill( ly, ui_colour( k_ui_fg ) );
1544 }
1545
1546 /*
1547 * Textbox chaos
1548 * -----------------------------------------------------------------------------
1549 */
1550
1551 static void _ui_textbox_make_selection( int *start, int *end ){
1552 *start = VG_MIN( vg_ui.textbox.cursor_pos, vg_ui.textbox.cursor_user );
1553 *end = VG_MAX( vg_ui.textbox.cursor_pos, vg_ui.textbox.cursor_user );
1554 }
1555
1556 static void _ui_textbox_move_cursor( int *cursor0, int *cursor1,
1557 int dir, int snap_together ){
1558 *cursor0 = VG_MAX( 0, vg_ui.textbox.cursor_user + dir );
1559 *cursor0 =
1560 VG_MIN(
1561 VG_MIN( vg_ui.textbox.len-1, strlen( vg_ui.textbuf )),
1562 *cursor0 );
1563
1564 if( snap_together )
1565 *cursor1 = *cursor0;
1566 }
1567
1568 static int _ui_textbox_makeroom( int datastart, int length ){
1569 int move_to = VG_MIN( datastart+length, vg_ui.textbox.len-1 );
1570 int move_amount = strlen( vg_ui.textbuf )-datastart;
1571 int move_end = VG_MIN( move_to+move_amount, vg_ui.textbox.len-1 );
1572 move_amount = move_end-move_to;
1573
1574 if( move_amount )
1575 memmove( &vg_ui.textbuf[ move_to ],
1576 &vg_ui.textbuf[ datastart ],
1577 move_end-move_to );
1578
1579 vg_ui.textbuf[ move_end ] = '\0';
1580
1581 return VG_MIN( length, vg_ui.textbox.len-datastart-1 );
1582 }
1583
1584 static int _ui_textbox_delete_char( int direction ){
1585 int start, end;
1586 _ui_textbox_make_selection( &start, &end );
1587
1588 /* There is no selection */
1589 if( !(end-start) ){
1590 if( direction == 1 ) end = VG_MIN( end+1, strlen( vg_ui.textbuf ) );
1591 else if( direction == -1 ) start = VG_MAX( start-1, 0 );
1592 }
1593
1594 /* Still no selction, no need to do anything */
1595 if( !(end-start) )
1596 return start;
1597
1598 /* Copy the end->terminator to start */
1599 int remaining_length = strlen( vg_ui.textbuf )+1-end;
1600 memmove( &vg_ui.textbuf[ start ],
1601 &vg_ui.textbuf[ end ],
1602 remaining_length );
1603 return start;
1604 }
1605
1606 static void _ui_textbox_to_clipboard(void){
1607 int start, end;
1608 _ui_textbox_make_selection( &start, &end );
1609 char buffer[512];
1610
1611 if( end-start ){
1612 memcpy( buffer, &vg_ui.textbuf[ start ], end-start );
1613 buffer[ end-start ] = 0x00;
1614 SDL_SetClipboardText( buffer );
1615 }
1616 }
1617
1618 static void _ui_textbox_change_callback(void){
1619 if( vg_ui.textbox.callbacks.change ){
1620 vg_ui.textbox.callbacks.change( vg_ui.textbuf, vg_ui.textbox.len );
1621
1622 /* we gave permission to modify the buffer in this callback so.. */
1623 int len = strlen( vg_ui.textbuf );
1624 vg_ui.textbox.cursor_user = VG_MIN( vg_ui.textbox.cursor_user, len );
1625 vg_ui.textbox.cursor_pos = VG_MIN( vg_ui.textbox.cursor_pos, len );
1626 }
1627 }
1628
1629 static void ui_start_modal( const char *message, u32 options );
1630 static void _ui_textbox_clipboard_paste(void){
1631 if( !SDL_HasClipboardText() )
1632 return;
1633
1634 char *text = SDL_GetClipboardText();
1635
1636 if( !text )
1637 return;
1638
1639 int datastart = _ui_textbox_delete_char( 0 );
1640 int length = strlen( text );
1641
1642 if( (vg_ui.textbox.len - strlen(vg_ui.textbuf)) < length ){
1643 ui_start_modal( "Clipboard content exceeds buffer size.", UI_MODAL_BAD );
1644 return;
1645 }
1646
1647 int cpylength = _ui_textbox_makeroom( datastart, length );
1648
1649 memcpy( vg_ui.textbuf + datastart, text, cpylength);
1650 _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
1651 &vg_ui.textbox.cursor_pos, cpylength, 1 );
1652 SDL_free( text );
1653 _ui_textbox_change_callback();
1654 }
1655
1656 static void _ui_textbox_put_char( char c ){
1657 vg_ui.textbox.cursor_user = _ui_textbox_delete_char(0);
1658 if( (vg_ui.textbox.len - strlen(vg_ui.textbuf)) <= 1 ) return;
1659
1660 if( _ui_textbox_makeroom( vg_ui.textbox.cursor_user, 1 ) )
1661 vg_ui.textbuf[ vg_ui.textbox.cursor_user ] = c;
1662
1663 _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
1664 &vg_ui.textbox.cursor_pos, 1, 1 );
1665 }
1666
1667 /* Receed secondary cursor */
1668 static void _ui_textbox_left_select(void){
1669 _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user, NULL, -1, 0 );
1670 }
1671
1672 /* Match and receed both cursors */
1673 static void _ui_textbox_left(void){
1674 int cursor_diff = vg_ui.textbox.cursor_pos - vg_ui.textbox.cursor_user? 0: 1;
1675
1676 _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
1677 &vg_ui.textbox.cursor_pos, -cursor_diff, 1 );
1678 }
1679
1680 static void _ui_textbox_up(void){
1681 if( vg_ui.textbox.flags & UI_TEXTBOX_MULTILINE ){
1682 int line_begin = vg_ui.textbox.cursor_user;
1683
1684 while( line_begin ){
1685 if( vg_ui.textbuf[ line_begin-1 ] == '\n' ){
1686 break;
1687 }
1688
1689 line_begin --;
1690 }
1691
1692 if( line_begin ){
1693 int line_above_begin = line_begin-1;
1694
1695 while( line_above_begin ){
1696 if( vg_ui.textbuf[ line_above_begin-1 ] == '\n' ){
1697 break;
1698 }
1699
1700 line_above_begin --;
1701 }
1702
1703 int offset = vg_ui.textbox.cursor_user - line_begin,
1704 line_length_above = line_begin - line_above_begin -1;
1705
1706 offset = VG_MIN( line_length_above, offset );
1707
1708 vg_ui.textbox.cursor_user = line_above_begin+offset;
1709 vg_ui.textbox.cursor_pos = line_above_begin+offset;
1710 }
1711 else{
1712 vg_ui.textbox.cursor_user = line_begin;
1713 vg_ui.textbox.cursor_pos = line_begin;
1714 }
1715 }
1716 else{
1717 if( vg_ui.textbox.callbacks.up ){
1718 vg_ui.textbox.callbacks.up( vg_ui.textbuf, vg_ui.textbox.len );
1719 }
1720 }
1721 }
1722
1723 static void _ui_textbox_down(void){
1724 if( vg_ui.textbox.flags & UI_TEXTBOX_MULTILINE ){
1725 int line_begin = vg_ui.textbox.cursor_user;
1726
1727 while( line_begin ){
1728 if( vg_ui.textbuf[ line_begin-1 ] == '\n' ){
1729 break;
1730 }
1731
1732 line_begin --;
1733 }
1734
1735 int line_below_begin = vg_ui.textbox.cursor_user;
1736
1737 while(1){
1738 if( vg_ui.textbuf[ line_below_begin ] == '\0' ){
1739 vg_ui.textbox.cursor_user = line_below_begin;
1740 vg_ui.textbox.cursor_pos = line_below_begin;
1741 return;
1742 }
1743
1744 if( vg_ui.textbuf[ line_below_begin ] == '\n' ){
1745 line_below_begin ++;
1746 break;
1747 }
1748
1749 line_below_begin ++;
1750 }
1751
1752 int line_below_end = line_below_begin;
1753 while(1){
1754 if( vg_ui.textbuf[ line_below_end ] == '\0' ||
1755 vg_ui.textbuf[ line_below_end ] == '\n' ){
1756 line_below_end ++;
1757 break;
1758 }
1759 line_below_end ++;
1760 }
1761
1762 int offset = vg_ui.textbox.cursor_user - line_begin,
1763 line_length_below = line_below_end - line_below_begin -1;
1764
1765 offset = VG_MIN( line_length_below, offset );
1766
1767 vg_ui.textbox.cursor_user = line_below_begin+offset;
1768 vg_ui.textbox.cursor_pos = line_below_begin+offset;
1769 }
1770 else{
1771 if( vg_ui.textbox.callbacks.down ){
1772 vg_ui.textbox.callbacks.down( vg_ui.textbuf, vg_ui.textbox.len );
1773 }
1774 }
1775 }
1776
1777 static void _ui_textbox_right_select(void){
1778 _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user, NULL, 1, 0 );
1779 }
1780
1781 static void _ui_textbox_right(void){
1782 int cursor_diff = vg_ui.textbox.cursor_pos - vg_ui.textbox.cursor_user? 0: 1;
1783
1784 _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
1785 &vg_ui.textbox.cursor_pos, +cursor_diff, 1 );
1786 }
1787
1788 static void _ui_textbox_backspace(void){
1789 if( vg_ui.focused_control_type == k_ui_control_textbox ){
1790 vg_ui.textbox.cursor_user = _ui_textbox_delete_char( -1 );
1791 vg_ui.textbox.cursor_pos = vg_ui.textbox.cursor_user;
1792 _ui_textbox_change_callback();
1793 }
1794 }
1795
1796 static void _ui_textbox_delete(void){
1797 if( vg_ui.focused_control_type == k_ui_control_textbox ){
1798 vg_ui.textbox.cursor_user = _ui_textbox_delete_char( 1 );
1799 vg_ui.textbox.cursor_pos = vg_ui.textbox.cursor_user;
1800 _ui_textbox_change_callback();
1801 }
1802 }
1803
1804 static void _ui_textbox_home_select(void){
1805 i32 start = vg_ui.textbox.cursor_user;
1806
1807 if( vg_ui.textbox.flags & UI_TEXTBOX_MULTILINE ){
1808 while( start ){
1809 if( vg_ui.textbuf[start-1] == '\n' )
1810 break;
1811 else
1812 start --;
1813 }
1814 }
1815 else
1816 start = 0;
1817
1818 vg_ui.textbox.cursor_user = start;
1819 }
1820
1821 static void _ui_textbox_home(void){
1822 _ui_textbox_home_select();
1823 vg_ui.textbox.cursor_pos = vg_ui.textbox.cursor_user;
1824 }
1825
1826 static void _ui_textbox_end_select(void){
1827 i32 end = vg_ui.textbox.cursor_user;
1828
1829 if( vg_ui.textbox.flags & UI_TEXTBOX_MULTILINE ){
1830 while( vg_ui.textbuf[end] ){
1831 if( vg_ui.textbuf[end] == '\n' )
1832 break;
1833 else
1834 end ++;
1835 }
1836 }
1837 else
1838 end = VG_MIN( vg_ui.textbox.len-1, strlen(vg_ui.textbuf) );
1839
1840 vg_ui.textbox.cursor_user = end;
1841 }
1842
1843 static void _ui_textbox_end(void){
1844 _ui_textbox_end_select();
1845 vg_ui.textbox.cursor_pos = vg_ui.textbox.cursor_user;
1846 }
1847
1848 static void _ui_textbox_select_all(void){
1849 _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user, NULL, 10000, 0);
1850 _ui_textbox_move_cursor( &vg_ui.textbox.cursor_pos, NULL, -10000, 0);
1851 }
1852
1853 static void _ui_textbox_cut(void){
1854 _ui_textbox_to_clipboard();
1855 vg_ui.textbox.cursor_user = _ui_textbox_delete_char(0);
1856 vg_ui.textbox.cursor_pos = vg_ui.textbox.cursor_user;
1857 _ui_textbox_change_callback();
1858 }
1859
1860 static void _ui_textbox_enter(void){
1861 if( vg_ui.focused_control_type == k_ui_control_textbox ){
1862 vg_ui.ignore_input_frames = 2;
1863
1864 if( vg_ui.textbox.callbacks.enter )
1865 vg_ui.textbox.callbacks.enter( vg_ui.textbuf, vg_ui.textbox.len );
1866
1867 if( vg_ui.focused_control_type != k_ui_control_textbox ) return;
1868
1869 if( vg_ui.textbox.flags & UI_TEXTBOX_MULTILINE ){
1870 _ui_textbox_put_char( '\n' );
1871 _ui_textbox_change_callback();
1872 }
1873 else{
1874 if( !(vg_ui.textbox.flags & UI_TEXTBOX_AUTOFOCUS ) )
1875 ui_defocus_all();
1876 }
1877 }
1878 }
1879
1880 /*
1881 * based on a visual character coordinate relative to the anchor of the textbox,
1882 * this works out the linear place in the buffer that coordinate maps to
1883 *
1884 * input coordinates go in co[0], co[1], and the result index is in co[2]
1885 */
1886 static void _ui_textbox_calc_index_from_grid( int co[3], int wrap_length ){
1887 int i[3] = {0,0,0};
1888
1889 char c;
1890 while( (c = vg_ui.textbuf[i[2]]) ){
1891 if( i[1]==co[1] && i[0]>=co[0] ) break;
1892
1893 if( i[0] >= wrap_length ){
1894 i[1] ++;
1895 i[0] = 0;
1896 }
1897
1898 if( c >= 32 && c <= 126 ){
1899 i[0] ++;
1900 i[2] ++;
1901 }
1902 else if( c == '\n' ){
1903 i[1] ++;
1904
1905 if( i[1] > co[1] ) break;
1906
1907 i[2] ++;
1908 i[0] = 0;
1909 }
1910 else i[2] ++;
1911 }
1912
1913 co[0] = i[0];
1914 co[1] = i[1];
1915 co[2] = i[2];
1916 }
1917
1918 /*
1919 * based on the index specied in co[2], work out the visual character
1920 * coordinates and store them in co[0], co[1]
1921 */
1922 static void _ui_textbox_index_calc_coords( int co[3], int wrap_length ){
1923 co[0] = 0;
1924 co[1] = 0;
1925
1926 char c;
1927 int i=0;
1928
1929 while( (c = vg_ui.textbuf[i ++]) ){
1930 if( i > co[2] ) break;
1931 if( co[0] >= wrap_length ){
1932 co[1] ++;
1933 co[0] = 0;
1934 }
1935 if( c >= 32 && c <= 126 ) co[0] ++;
1936 else if( c == '\n' ){
1937 co[1] ++;
1938 co[0] = 0;
1939 }
1940 }
1941 }
1942
1943 /*
1944 * calculate the number of characters remaining until either:
1945 * - the wrap_length limit is hit
1946 * - end of the line/string
1947 *
1948 * index must be fully populated with visual X/Y, and linear index
1949 */
1950 static int _ui_textbox_run_remaining( int index[3], int wrap_length ){
1951 int i=0, printed_chars=0;
1952 char c;
1953 while( (c = vg_ui.textbuf[index[2] + (i ++)]) ){
1954 if( index[0]+i >= wrap_length ) break;
1955 if( c >= 32 && c <= 126 ) printed_chars ++;
1956 else if( c == '\n' ) break;
1957 }
1958
1959 return printed_chars+1;
1960 }
1961
1962 static int ui_textbox( ui_rect inout_panel, const char *label,
1963 char *buf, u32 len, u32 lines, u32 flags,
1964 struct ui_textbox_callbacks *callbacks ){
1965 assert( lines > 0 );
1966 assert( buf );
1967
1968 if( lines > 1 ) flags |= UI_TEXTBOX_MULTILINE;
1969
1970 ui_rect rect;
1971 ui_standard_widget( inout_panel, rect, lines );
1972
1973 if( label )
1974 ui_label( rect, label, 1, 0, rect );
1975
1976 int clickup= ui_click_up(UI_MOUSE_LEFT),
1977 clickdown = ui_click_down(UI_MOUSE_LEFT),
1978 click = ui_clicking(UI_MOUSE_LEFT) | clickup,
1979 target = ui_inside_rect( rect, vg_ui.mouse_click ) && click,
1980 hover = ui_inside_rect( rect, vg_ui.mouse );
1981
1982 /* allow instant transitions from textbox->textbox */
1983 if( (vg_ui.focused_control_type != k_ui_control_none) &&
1984 (vg_ui.focused_control_type != k_ui_control_textbox) ){
1985 clickup = 0;
1986 clickdown = 0;
1987 click = 0;
1988 target = 0;
1989 hover = 0;
1990 flags &= ~UI_TEXTBOX_AUTOFOCUS;
1991 }
1992
1993 u32 col_base = ui_colour( k_ui_bg ),
1994 col_highlight = ui_colour( k_ui_fg ),
1995 col_cursor = (0x00ffffff & ui_colour(k_ui_fg))|0x7f000000;
1996
1997 ui_px border = -1;
1998
1999 ui_rect text_rect;
2000 rect_copy( rect, text_rect );
2001
2002 if( flags & UI_TEXTBOX_MULTILINE ) text_rect[3] = rect[3]-16;
2003 else text_rect[3] = vg_ui.font->line_height;
2004
2005 text_rect[2] -= 16;
2006 ui_rect_center( rect, text_rect );
2007
2008 ui_px wrap_length = 1024;
2009
2010 if( flags & UI_TEXTBOX_WRAP )
2011 wrap_length = text_rect[2] / vg_ui.font->spacing;
2012
2013 if( hover ){
2014 vg_ui.cursor = k_ui_cursor_ibeam;
2015 }
2016
2017 if( vg_ui.focused_control_id == buf ){
2018 ui_fill( rect, col_base );
2019 ui_ntext( text_rect, buf, wrap_length, 1, k_ui_align_left, 0 );
2020
2021 if( !(flags & UI_TEXTBOX_AUTOFOCUS) && ((clickup||clickdown) && !target)){
2022 ui_defocus_all();
2023 }
2024 else{
2025 vg_ui.focused_control_hit = 1;
2026 if( click && target ){
2027 int p0[3] ={
2028 (vg_ui.mouse_click[0] - text_rect[0]) / vg_ui.font->spacing,
2029 (vg_ui.mouse_click[1] - text_rect[1]) / vg_ui.font->line_height,
2030 -1
2031 },
2032 p1[3] = {
2033 (vg_ui.mouse[0] - text_rect[0]) / vg_ui.font->spacing,
2034 (vg_ui.mouse[1] - text_rect[1]) / vg_ui.font->line_height,
2035 -1
2036 };
2037
2038 if( flags & UI_TEXTBOX_MULTILINE ){
2039 _ui_textbox_calc_index_from_grid( p0, wrap_length );
2040 _ui_textbox_calc_index_from_grid( p1, wrap_length );
2041
2042 vg_ui.textbox.cursor_pos = p0[2];
2043 vg_ui.textbox.cursor_user = p1[2];
2044 }
2045 else{
2046 int max = strlen( buf );
2047 vg_ui.textbox.cursor_pos = VG_MAX( 0, VG_MIN( max, p0[0] )),
2048 vg_ui.textbox.cursor_user = VG_MAX( 0, VG_MIN( max, p1[0] ));
2049 }
2050 }
2051
2052 ui_outline( rect, -2, vg_ui.scheme[ k_ui_orange ], 0 );
2053
2054 ui_rect cursor;
2055
2056 int c0 = vg_ui.textbox.cursor_pos,
2057 c1 = vg_ui.textbox.cursor_user,
2058 start = VG_MIN( c0, c1 ),
2059 end = VG_MAX( c0, c1 ),
2060 chars = end-start;
2061
2062 if( flags & (UI_TEXTBOX_WRAP|UI_TEXTBOX_MULTILINE) ){
2063 int pos[3], remaining = chars;
2064
2065 pos[2] = start;
2066 _ui_textbox_index_calc_coords( pos, wrap_length );
2067
2068 if( start==end ){
2069 cursor[0] = text_rect[0] + pos[0]*vg_ui.font->spacing-1;
2070 cursor[1] = text_rect[1] + pos[1]*14;
2071 cursor[2] = 2;
2072 cursor[3] = 13;
2073 ui_fill( cursor, col_cursor );
2074 rect_copy( cursor, vg_ui.click_fader_end );
2075 }
2076 else{
2077 while( remaining ){
2078 int run = _ui_textbox_run_remaining( pos, wrap_length );
2079 run = VG_MIN( run, remaining );
2080
2081 cursor[0] = text_rect[0] + pos[0]*vg_ui.font->spacing-1;
2082 cursor[1] = text_rect[1] + pos[1]*14;
2083 cursor[2] = (float)(run)*(float)vg_ui.font->spacing;
2084 cursor[3] = 13;
2085
2086 ui_fill( cursor, col_cursor );
2087
2088 remaining -= run;
2089 pos[0] = 0;
2090 pos[1] ++;
2091 pos[2] += run;
2092 }
2093 rect_copy( cursor, vg_ui.click_fader_end );
2094 }
2095 }
2096 else{
2097 cursor[0] = text_rect[0] + start*vg_ui.font->spacing-1;
2098 cursor[1] = text_rect[1];
2099 cursor[3] = 13;
2100
2101 if( start==end ){
2102 cursor[2] = 2;
2103 }
2104 else{
2105 cursor[2] = (float)(chars)*(float)vg_ui.font->spacing;
2106 }
2107
2108 if( (vg_ui.click_fade_opacity<=0.0f) &&
2109 ui_clip( rect, cursor, cursor ) ){
2110 ui_fill( cursor, col_cursor );
2111 }
2112
2113 rect_copy( cursor, vg_ui.click_fader_end );
2114 }
2115 }
2116
2117 return 0;
2118 }
2119
2120 if( click || (flags & UI_TEXTBOX_AUTOFOCUS) ){
2121 if( (target && hover) || (flags & UI_TEXTBOX_AUTOFOCUS) ){
2122 ui_defocus_all();
2123
2124 ui_fill( rect, col_highlight );
2125 vg_ui.ignore_input_frames = 2;
2126 rect_copy( rect, vg_ui.click_fader );
2127 rect_copy( rect, vg_ui.click_fader_end );
2128
2129 vg_ui.click_fade_opacity = 1.0f;
2130 vg_ui.textbuf = buf;
2131 vg_ui.focused_control_hit = 1;
2132 vg_ui.focused_control_type = k_ui_control_textbox;
2133 vg_ui.textbox.len = len;
2134 vg_ui.textbox.flags = flags;
2135 vg_ui.textbox.cursor_pos = 0;
2136 vg_ui.textbox.cursor_user = 0;
2137
2138 if( callbacks ){
2139 vg_ui.textbox.callbacks = *callbacks;
2140 }
2141 else{
2142 vg_ui.textbox.callbacks.change = NULL;
2143 vg_ui.textbox.callbacks.down = NULL;
2144 vg_ui.textbox.callbacks.up = NULL;
2145 vg_ui.textbox.callbacks.enter = NULL;
2146 }
2147
2148 SDL_StartTextInput();
2149 }
2150 }
2151
2152 ui_fill( rect, col_base );
2153
2154 if( hover ){
2155 ui_outline( rect, -1, col_highlight, 0 );
2156 }
2157
2158 ui_ntext( text_rect, buf, wrap_length, 1, k_ui_align_left, 0 );
2159 return 0;
2160 }
2161
2162 /*
2163 * Tabs
2164 * -----------------------------------------------------------------------------
2165 */
2166
2167 static void ui_tabs( ui_rect inout_panel, ui_rect out_content_panel,
2168 const char **titles, u32 count, i32 *page ){
2169 ui_rect bar;
2170 ui_standard_widget( inout_panel, bar, 1 );
2171
2172 i32 cur_page = *page;
2173
2174 f32 width = (f32)inout_panel[2] / (f32)count;
2175
2176 ui_px h = (inout_panel[1] + inout_panel[3]) - (bar[1]+bar[3]);
2177 inout_panel[1] = bar[1]+bar[3];
2178 inout_panel[3] = h;
2179
2180 ui_fill( inout_panel, ui_colour( k_ui_bg+2 ) );
2181 ui_outline( inout_panel, 1, ui_colour( k_ui_bg+5 ), 0 );
2182
2183 rect_copy( inout_panel, out_content_panel );
2184 ui_rect_pad( out_content_panel, (ui_px[2]){ k_ui_padding, k_ui_padding } );
2185
2186 /* place buttons */
2187 for( i32 i=0; i<count; i++ ){
2188 ui_rect button = {
2189 bar[0] + ((f32)i*width),
2190 bar[1],
2191 width,
2192 bar[3]-1
2193 };
2194
2195 enum ui_scheme_colour colour = k_ui_bg+4;
2196 if( i == cur_page ){
2197 colour = k_ui_bg+2;
2198 ui_outline( button, 1, ui_colour( k_ui_bg+5 ),
2199 UI_TOP|UI_LEFT|UI_RIGHT );
2200 button[3] ++;
2201 }
2202
2203 if( ui_colourbutton_text( button, titles[i], 1, colour ) == 1 )
2204 *page = i;
2205 }
2206 }
2207
2208 /*
2209 * Modal UI
2210 * -----------------------------------------------------------------------------
2211 */
2212 static void ui_start_modal( const char *message, u32 options ){
2213 vg_ui.focused_control_type = k_ui_control_modal;
2214 vg_ui.modal.message = message;
2215 vg_ui.modal.callbacks.close = NULL;
2216 vg_ui.modal.options = options;
2217
2218 u32 type = options & UI_MODAL_TYPE_BITS;
2219 if( type == UI_MODAL_OK ) vg_info( message );
2220 else if( type == UI_MODAL_WARN ) vg_warn( message );
2221 else if( type == UI_MODAL_GOOD ) vg_success( message );
2222 else if( type == UI_MODAL_BAD ) vg_error( message );
2223 }
2224
2225 /*
2226 * Input handling
2227 * -----------------------------------------------------------------------------
2228 */
2229
2230 /*
2231 * Handles binds
2232 */
2233 static void _ui_proc_key( SDL_Keysym ev ){
2234 if( vg_ui.focused_control_type != k_ui_control_textbox ){
2235 return;
2236 }
2237
2238 struct textbox_mapping{
2239 u16 mod;
2240 SDL_Keycode key;
2241
2242 void (*handler)(void);
2243 }
2244 mappings[] =
2245 {
2246 { 0, SDLK_LEFT, _ui_textbox_left },
2247 { KMOD_SHIFT, SDLK_LEFT, _ui_textbox_left_select },
2248 { 0, SDLK_RIGHT, _ui_textbox_right },
2249 { KMOD_SHIFT, SDLK_RIGHT, _ui_textbox_right_select },
2250 { 0, SDLK_DOWN, _ui_textbox_down },
2251 { 0, SDLK_UP, _ui_textbox_up },
2252 { 0, SDLK_BACKSPACE, _ui_textbox_backspace },
2253 { KMOD_SHIFT, SDLK_BACKSPACE, _ui_textbox_backspace },
2254 { KMOD_CTRL, SDLK_BACKSPACE, _ui_textbox_backspace },
2255 { 0, SDLK_DELETE, _ui_textbox_delete },
2256 { 0, SDLK_HOME, _ui_textbox_home },
2257 { KMOD_SHIFT, SDLK_HOME, _ui_textbox_home_select },
2258 { 0, SDLK_END, _ui_textbox_end },
2259 { KMOD_SHIFT, SDLK_END, _ui_textbox_end_select },
2260 { KMOD_CTRL, SDLK_a, _ui_textbox_select_all },
2261 { KMOD_CTRL, SDLK_c, _ui_textbox_to_clipboard },
2262 { KMOD_CTRL, SDLK_x, _ui_textbox_cut },
2263 { KMOD_CTRL, SDLK_v, _ui_textbox_clipboard_paste },
2264 { 0, SDLK_RETURN, _ui_textbox_enter },
2265 { 0, SDLK_ESCAPE, ui_defocus_all },
2266 };
2267
2268 SDL_Keymod mod = 0;
2269
2270 if( ev.mod & KMOD_SHIFT )
2271 mod |= KMOD_SHIFT;
2272
2273 if( ev.mod & KMOD_CTRL )
2274 mod |= KMOD_CTRL;
2275
2276 if( ev.mod & KMOD_ALT )
2277 mod |= KMOD_ALT;
2278
2279 for( int i=0; i<vg_list_size( mappings ); i++ ){
2280 struct textbox_mapping *mapping = &mappings[i];
2281
2282 if( mapping->key == ev.sym ){
2283 if( mapping->mod == 0 ){
2284 if( mod == 0 ){
2285 mapping->handler();
2286 return;
2287 }
2288 }
2289 else if( (mod & mapping->mod) == mapping->mod ){
2290 mapping->handler();
2291 return;
2292 }
2293 }
2294 }
2295 }
2296
2297 /*
2298 * Callback for text entry mode
2299 */
2300 static void ui_proc_utf8( const char *text ){
2301 if( vg_ui.focused_control_type == k_ui_control_textbox ){
2302 const char *ptr = text;
2303
2304 while( *ptr ){
2305 if( *ptr != '`' ) _ui_textbox_put_char( *ptr );
2306 ptr ++;
2307 }
2308
2309 _ui_textbox_change_callback();
2310 }
2311 }
2312
2313 /*
2314 * Development utils
2315 * -----------------------------------------------------------------------------
2316 */
2317
2318 static void ui_dev_colourview(void){
2319 ui_rect window = {vg.window_x-256,0,256,vg.window_y}, swatch;
2320
2321 const char *names[vg_list_size(vg_ui.scheme)] = {
2322 [k_ui_bg] = "k_ui_bg", "k_ui_bg+1", "k_ui_bg+2", "k_ui_bg+3",
2323 "k_ui_bg+4", "k_ui_bg+5", "k_ui_bg+6", "k_ui_bg+7",
2324
2325 [k_ui_fg] = "k_ui_fg", "k_ui_fg+1", "k_ui_fg+2", "k_ui_fg+3",
2326 "k_ui_fg+4", "k_ui_fg+5", "k_ui_fg+6", "k_ui_fg+7",
2327
2328 [k_ui_red] = "k_ui_red", "k_ui_orange", "k_ui_yellow", "k_ui_green",
2329 "k_ui_aqua", "k_ui_blue", "k_ui_purple", "k_ui_gray",
2330 "k_ui_red+8","k_ui_orange+8","k_ui_yellow+8","k_ui_green+8",
2331 "k_ui_aqua+8","k_ui_blue+8","k_ui_purple+8","k_ui_gray+8" };
2332
2333 ui_rect col[2];
2334 ui_split_ratio( window, k_ui_axis_v, 0.5f, 0, col[0], col[1] );
2335
2336 for( int i=0; i<vg_list_size(vg_ui.scheme); i++ ){
2337 int which = (i/8)%2;
2338
2339 ui_split( col[which], k_ui_axis_h, 24, 0, swatch, col[which] );
2340 ui_fill( swatch, ui_colour(i) );
2341
2342 if( names[i] )
2343 ui_text(swatch, names[i], 1, k_ui_align_middle_left, ui_colourcont(i));
2344 }
2345 }
2346
2347 #endif /* VG_IMGUI_H */
Voyager Game Engine