projects / vg.git / blob
? search:


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