1e120e28aad5e9e67f3b1796401a19181d9824a3
[vg.git] / vg_ui.h
1 /* Copyright (C) 2021-2022 Harry Godden (hgn) - All Rights Reserved */
2
3 #ifndef VG_UI_H
4 #define VG_UI_H
5
6 #define VG_GAME
7 #include "vg/vg.h"
8 #include "vg/vg_tex.h"
9 #include "vg/vg_shader.h"
10
11 static struct vg_shader _shader_ui =
12 {
13 .name = "[vg] ui",
14 .link = NULL,
15 .vs =
16 {
17 .orig_file = NULL,
18 .static_src =
19 "layout (location=0) in vec2 a_co;"
20 "layout (location=1) in vec2 a_uv;"
21 "layout (location=2) in vec4 a_colour;"
22 "layout (location=3) in vec4 a_clip;"
23 "uniform mat3 uPv;"
24 ""
25 "out vec2 aTexCoords;"
26 "out vec4 aColour;"
27 "out vec2 aWsp;"
28 "out vec4 aClip;"
29 ""
30 "void main()"
31 "{"
32 "gl_Position = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
33 "aTexCoords = a_uv * 0.0078125;"
34 "aColour = a_colour;"
35
36 "aWsp = a_co;"
37 "aClip = a_clip;"
38 "}",
39 },
40 .fs =
41 {
42 .orig_file = NULL,
43 .static_src =
44 "uniform sampler2D uTexGlyphs;"
45 "out vec4 FragColor;"
46 ""
47 "in vec2 aTexCoords;"
48 "in vec4 aColour;"
49 ""
50 "in vec2 aWsp;"
51 "in vec4 aClip;"
52 ""
53 "void main()"
54 "{"
55 "float clip_blend = step( aWsp.x, aClip.z ) *"
56 "step( aWsp.y, aClip.w ) *"
57 "step( aClip.x, aWsp.x ) *"
58 "step( aClip.y, aWsp.y ); "
59
60 "vec4 glyph = vec4(1.0,1.0,1.0,1.0);"
61
62 "if( aColour.a == 0.0 )"
63 "{"
64 "glyph = texture( uTexGlyphs, aTexCoords );"
65 "glyph.a = smoothstep( 0.47, 0.53, glyph.r );"
66 "}"
67 "else"
68 "{"
69 "glyph.a = aColour.a;"
70 "}"
71
72 "FragColor = vec4( aColour.rgb, glyph.a*clip_blend );"
73 "}"
74 }
75 };
76
77 static struct vg_shader _shader_ui_image =
78 {
79 .name = "[vg] ui_image",
80 .link = NULL,
81 .vs =
82 {
83 .orig_file = NULL,
84 .static_src =
85 "layout (location=0) in vec2 a_co;"
86 "layout (location=1) in vec2 a_uv;"
87 "layout (location=2) in vec4 a_colour;"
88 "layout (location=3) in vec4 a_clip;"
89 "uniform mat3 uPv;"
90 ""
91 "out vec2 aTexCoords;"
92 "out vec4 aColour;"
93 "out vec2 aWsp;"
94 "out vec4 aClip;"
95 ""
96 "void main()"
97 "{"
98 "gl_Position = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
99 "aTexCoords = a_uv * 0.0078125;"
100 "aColour = a_colour;"
101
102 "aWsp = a_co;"
103 "aClip = a_clip;"
104 "}",
105 },
106 .fs =
107 {
108 .orig_file = NULL,
109 .static_src =
110 "uniform sampler2D uTexImage;"
111 "out vec4 FragColor;"
112 ""
113 "in vec2 aTexCoords;"
114 "in vec4 aColour;"
115 ""
116 "in vec2 aWsp;"
117 "in vec4 aClip;"
118
119 "void main()"
120 "{"
121 "float clip_blend = step( aWsp.x, aClip.z ) *"
122 "step( aWsp.y, aClip.w ) *"
123 "step( aClip.x, aWsp.x ) *"
124 "step( aClip.y, aWsp.y ); "
125
126 "vec4 colour = texture( uTexImage, aTexCoords );"
127 "float value = dot(vec4(1.0),colour)*0.25;"
128
129 "vec3 col = vec3(pow(cos(value*3.14159265*2.0)*0.5+0.5,0.5))"
130 "* vec3(step(value,0.5),0.3,step(1.0-value,0.5));"
131
132 "FragColor = vec4( col*4.0, clip_blend );"
133 "}"
134 }
135 };
136
137 typedef i16 ui_px;
138 typedef u32 ui_colour;
139 typedef ui_px ui_rect[4];
140 typedef struct ui_colourset ui_colourset;
141
142 /* Relative to cursor p0 */
143 enum ui_text_align
144 {
145 k_text_align_left = 0,
146 k_text_align_right = 1,
147 k_text_align_center = 2
148 };
149
150 struct ui_colourset
151 {
152 union
153 {
154 struct
155 {
156 ui_colour main;
157 ui_colour hover;
158 ui_colour active;
159 };
160 struct
161 {
162 ui_colour background;
163 ui_colour bar;
164 ui_colour bar_hover;
165 };
166 };
167 };
168
169 #pragma pack(push,1)
170 struct ui_vert
171 {
172 ui_px co[2];
173 u8 uv[2];
174 u32 colour;
175 ui_rect clip;
176 };
177 #pragma pack(pop)
178
179 struct
180 {
181 struct ui_qnode
182 {
183 ui_rect rect;
184 ui_colour colour;
185 int mouse_over;
186 int capture_id;
187 }
188 stack[ 32 ];
189
190 u32 control_id;
191
192 struct ui_vert *vertex_buffer;
193 u16 *indice_buffer;
194 u32 max_verts, max_indices, cur_vert, cur_indice;
195
196 ui_rect clipping;
197 ui_rect cursor;
198 u32 stack_count;
199 u32 capture_mouse_id;
200 int capture_lock;
201
202 /* User input */
203 ui_px mouse[2];
204 int click_state; /* 0: released, 1: on down, 2: pressed, 3: on release */
205
206 ui_colourset *colours;
207
208 GLuint vao;
209 GLuint vbo;
210 GLuint ebo;
211
212 struct ui_image
213 {
214 ui_rect rc;
215 GLuint image;
216 }
217 images[16];
218 int image_count;
219 }
220 static vg_uictx;
221
222 #define UI_GLYPH_SPACING_X 8
223
224 static GLuint ui_glyph_texture = 0;
225 static ui_colourset ui_default_colours = {
226 .main = 0xff807373,
227 .hover = 0xff918484,
228 .active = 0xffad9f9e
229 };
230
231 VG_STATIC void _vg_ui_init(void)
232 {
233 if( !vg_shader_compile( &_shader_ui ) ||
234 !vg_shader_compile( &_shader_ui_image ) )
235 vg_fatal_exit_loop( "Failed to compile ui shader" );
236
237 /*
238 * Vertex buffer
239 * ----------------------------------------
240 */
241
242 vg_uictx.max_indices = 20000;
243 vg_uictx.max_verts = 30000;
244 vg_uictx.colours = &ui_default_colours;
245
246 /* Generate the buffer we are gonna be drawing to */
247 glGenVertexArrays( 1, &vg_uictx.vao );
248 glGenBuffers( 1, &vg_uictx.vbo );
249 glGenBuffers( 1, &vg_uictx.ebo );
250
251 glBindVertexArray( vg_uictx.vao );
252 glBindBuffer( GL_ARRAY_BUFFER, vg_uictx.vbo );
253
254 glBufferData( GL_ARRAY_BUFFER,
255 vg_uictx.max_verts * sizeof( struct ui_vert ),
256 NULL, GL_DYNAMIC_DRAW );
257 glBindVertexArray( vg_uictx.vao );
258
259 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vg_uictx.ebo );
260 glBufferData( GL_ELEMENT_ARRAY_BUFFER,
261 vg_uictx.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,
270 stride, (void *)offsetof( struct ui_vert, co ) );
271 glEnableVertexAttribArray( 0 );
272
273 /* UV */
274 glVertexAttribPointer( 1, 2, GL_UNSIGNED_BYTE, GL_FALSE,
275 stride, (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 /* CLIPPING */
284 glVertexAttribPointer( 3, 4, GL_SHORT, GL_FALSE, stride,
285 (void *)offsetof( struct ui_vert, clip ) );
286 glEnableVertexAttribArray( 3 );
287
288 VG_CHECK_GL_ERR();
289
290 /* Alloc RAM default context */
291 u32 vert_size = vg_uictx.max_verts*sizeof(struct ui_vert),
292 inds_size = vg_align8( vg_uictx.max_indices*sizeof(u16) );
293
294 vg_uictx.vertex_buffer = vg_linear_alloc( vg_mem.rtmemory, vert_size );
295 vg_uictx.indice_buffer = vg_linear_alloc( vg_mem.rtmemory, inds_size );
296
297 /* font
298 * -----------------------------------------------------
299 */
300
301 /* Load default font */
302 u32 compressed[] = {
303 #include "vg/vg_pxfont_thin.h"
304 };
305
306 u32 pixels = 0, total = 256*256, data = 0;
307 u8 image[256*256];
308
309 while( pixels < total ){
310 for( int b = 31; b >= 0; b-- ){
311 image[ pixels ++ ] = (compressed[data] & (0x1u << b))? 0xffu: 0x00u;
312
313 if( pixels >= total ){
314 total = 0;
315 break;
316 }
317 }
318 data++;
319 }
320
321 glGenTextures( 1, &ui_glyph_texture );
322 glBindTexture( GL_TEXTURE_2D, ui_glyph_texture );
323 glTexImage2D( GL_TEXTURE_2D, 0, GL_R8, 256, 256, 0,
324 GL_RED, GL_UNSIGNED_BYTE, image );
325
326 VG_CHECK_GL_ERR();
327 vg_tex2d_clamp();
328 vg_tex2d_nearest();
329 }
330
331 static struct ui_vert *ui_fill_rect_uv( ui_rect rect, u32 colour, ui_px uv[4] );
332
333 VG_STATIC void ui_draw( m3x3f view_override )
334 {
335 u32 num_indices_normal = vg_uictx.cur_indice;
336
337 /* Append images to back of buffer */
338 for( int i = 0; i < vg_uictx.image_count; i ++ )
339 {
340 ui_fill_rect_uv( vg_uictx.images[i].rc, 0xffffffff,
341 (ui_px[4]){0,0,128,128} );
342 }
343
344 glBindVertexArray( vg_uictx.vao );
345
346 glBindBuffer( GL_ARRAY_BUFFER, vg_uictx.vbo );
347 glBufferSubData( GL_ARRAY_BUFFER, 0,
348 vg_uictx.cur_vert * sizeof( struct ui_vert ),
349 vg_uictx.vertex_buffer );
350
351 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vg_uictx.ebo );
352 glBufferSubData( GL_ELEMENT_ARRAY_BUFFER, 0,
353 vg_uictx.cur_indice * sizeof( u16 ),
354 vg_uictx.indice_buffer );
355
356 glEnable(GL_BLEND);
357 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
358 glBlendEquation(GL_FUNC_ADD);
359
360 glUseProgram( _shader_ui.id );
361
362 m3x3f view = M3X3_IDENTITY;
363
364 if( !view_override )
365 {
366 view_override = view;
367
368 m3x3_translate( view, (v3f){ -1.0f, 1.0f, 0.0f } );
369 m3x3_scale( view, (v3f){ 1.0f/((float)vg.window_x*0.5f),
370 -1.0f/((float)vg.window_y*0.5f), 1.0f } );
371 }
372
373 /* TODO? */
374 glUniformMatrix3fv( glGetUniformLocation( _shader_ui.id, "uPv" ), 1,
375 GL_FALSE, (float *)view_override );
376
377 glActiveTexture( GL_TEXTURE0 );
378 glBindTexture( GL_TEXTURE_2D, ui_glyph_texture );
379 glUniform1i( glGetUniformLocation( _shader_ui.id, "uTexGlyphs" ), 0 );
380
381 glDrawElements( GL_TRIANGLES, num_indices_normal,
382 GL_UNSIGNED_SHORT, (void*)(0) );
383
384
385 /* images */
386 glUseProgram( _shader_ui_image.id );
387 glUniformMatrix3fv( glGetUniformLocation( _shader_ui_image.id, "uPv" ), 1,
388 GL_FALSE, (float *)view_override );
389
390 glActiveTexture( GL_TEXTURE1 );
391 glUniform1i( glGetUniformLocation( _shader_ui_image.id, "uTexImage" ), 1 );
392
393 /* Draw image elements */
394 for( int i = 0; i < vg_uictx.image_count; i ++ )
395 {
396 struct ui_image *img = &vg_uictx.images[i];
397
398 glBindTexture( GL_TEXTURE_2D, img->image );
399 glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT,
400 (void*)( (num_indices_normal + 6*i)*sizeof(u16) ) );
401 }
402
403 glDisable(GL_BLEND);
404 }
405
406 /*
407 * Rect controls
408 */
409 VG_STATIC void ui_rect_copy( ui_rect src, ui_rect dst )
410 {
411 dst[0] = src[0];
412 dst[1] = src[1];
413 dst[2] = src[2];
414 dst[3] = src[3];
415 }
416
417 VG_STATIC void ui_rect_pad( ui_rect rect, ui_px pad )
418 {
419 rect[0] += pad;
420 rect[1] += pad;
421 rect[2] -= pad*2;
422 rect[3] -= pad*2;
423 }
424
425 /*
426 * Stack control
427 */
428 static struct ui_qnode *ui_current(void)
429 {
430 return &vg_uictx.stack[ vg_uictx.stack_count-1 ];
431 }
432
433 VG_STATIC void ui_new_node(void)
434 {
435 if( vg_uictx.stack_count == vg_list_size( vg_uictx.stack ) )
436 {
437 vg_error( "[UI] Stack overflow while creating box!" );
438 return;
439 }
440
441 struct ui_qnode *parent = &vg_uictx.stack[ vg_uictx.stack_count-1 ];
442 struct ui_qnode *node = &vg_uictx.stack[ vg_uictx.stack_count++ ];
443 ui_rect_copy( vg_uictx.cursor, node->rect );
444
445 if( parent->mouse_over )
446 {
447 if( vg_uictx.mouse[0] >= node->rect[0] &&
448 vg_uictx.mouse[0] < node->rect[0]+node->rect[2] &&
449 vg_uictx.mouse[1] >= node->rect[1] &&
450 vg_uictx.mouse[1] < node->rect[1]+node->rect[3] )
451 node->mouse_over = 1;
452 else
453 node->mouse_over = 0;
454 }
455 else
456 {
457 node->mouse_over = 0;
458 }
459 }
460
461 static int ui_hasmouse(void)
462 {
463 struct ui_qnode *node = ui_current();
464 return (node->mouse_over && (node->capture_id == vg_uictx.capture_mouse_id));
465 }
466
467 VG_STATIC void ui_end(void)
468 {
469 struct ui_qnode *node = &vg_uictx.stack[ --vg_uictx.stack_count ];
470 ui_rect_copy( node->rect, vg_uictx.cursor );
471 }
472
473 VG_STATIC void ui_end_down(void)
474 {
475 ui_px height = ui_current()->rect[3];
476 ui_end();
477 vg_uictx.cursor[1] += height;
478 }
479
480 VG_STATIC void ui_end_right(void)
481 {
482 ui_px width = ui_current()->rect[2];
483 ui_end();
484 vg_uictx.cursor[0] += width;
485 }
486
487 VG_STATIC void ui_fill_y(void)
488 {
489 struct ui_qnode *node = ui_current();
490 vg_uictx.cursor[3] = node->rect[3] - (vg_uictx.cursor[1]-node->rect[1]);
491 }
492
493 VG_STATIC void ui_fill_x(void)
494 {
495 struct ui_qnode *node = ui_current();
496 vg_uictx.cursor[2] = node->rect[2] - (vg_uictx.cursor[0]-node->rect[0]);
497 }
498
499 VG_STATIC void ui_align_bottom(void)
500 {
501 struct ui_qnode *node = ui_current();
502 vg_uictx.cursor[1] = node->rect[1] + node->rect[3] - vg_uictx.cursor[3];
503 }
504
505 VG_STATIC void ui_align_right(void)
506 {
507 struct ui_qnode *node = ui_current();
508 vg_uictx.cursor[0] = node->rect[0] + node->rect[2] - vg_uictx.cursor[2];
509 }
510
511 VG_STATIC void ui_align_top(void)
512 {
513 vg_uictx.cursor[1] = ui_current()->rect[1];
514 }
515
516 VG_STATIC void ui_align_left(void)
517 {
518 vg_uictx.cursor[0] = ui_current()->rect[0];
519 }
520
521 VG_STATIC void ui_clamp_rect( ui_rect parent, ui_rect dest )
522 {
523 dest[0] = vg_min( parent[0] + parent[2] - dest[2], dest[0] );
524 dest[1] = vg_min( parent[1] + parent[3] - dest[3], dest[1] );
525 dest[0] = vg_max( parent[0], dest[0] );
526 dest[1] = vg_max( parent[1], dest[1] );
527 }
528
529 VG_STATIC void ui_capture_mouse( u32 id )
530 {
531 struct ui_qnode *node = &vg_uictx.stack[ vg_uictx.stack_count-1 ];
532 node->capture_id = id;
533
534 if( !vg_uictx.capture_lock && node->mouse_over )
535 {
536 vg_uictx.capture_mouse_id = id;
537 }
538 }
539
540 static int ui_want_mouse(void)
541 {
542 return vg_uictx.capture_mouse_id == 0? 0: 1;
543 }
544
545 VG_STATIC void ui_set_clip( ui_rect clip )
546 {
547 vg_uictx.clipping[0] = clip[0];
548 vg_uictx.clipping[1] = clip[1];
549 vg_uictx.clipping[2] = clip[0] + clip[2];
550 vg_uictx.clipping[3] = clip[1] + clip[3];
551 }
552
553 VG_STATIC void ui_release_clip(void)
554 {
555 vg_uictx.clipping[0] = -32000;
556 vg_uictx.clipping[1] = -32000;
557 vg_uictx.clipping[2] = 32000;
558 vg_uictx.clipping[3] = 32000;
559 }
560
561 static struct ui_vert *ui_fill_rect_uv( ui_rect rect, u32 colour, ui_px uv[4] )
562 {
563 /* this if far from ideal but stops us from crashing */
564 if( (vg_uictx.cur_vert + 6 > vg_uictx.max_verts) ||
565 (vg_uictx.cur_indice + 4 > vg_uictx.max_indices))
566 return vg_uictx.vertex_buffer;
567
568 struct ui_vert *vertices = &vg_uictx.vertex_buffer[ vg_uictx.cur_vert ];
569 u16 *indices = &vg_uictx.indice_buffer[ vg_uictx.cur_indice ];
570
571 vertices[0].co[0] = rect[0];
572 vertices[0].co[1] = rect[1];
573 vertices[0].uv[0] = uv[0];
574 vertices[0].uv[1] = uv[1];
575 vertices[0].colour = colour;
576 vertices[1].co[0] = rect[0]+rect[2];
577 vertices[1].co[1] = rect[1];
578 vertices[1].uv[0] = uv[2];
579 vertices[1].uv[1] = uv[1];
580 vertices[1].colour = colour;
581 vertices[2].co[0] = rect[0]+rect[2];
582 vertices[2].co[1] = rect[1]+rect[3];
583 vertices[2].uv[0] = uv[2];
584 vertices[2].uv[1] = uv[3];
585 vertices[2].colour = colour;
586 vertices[3].co[0] = rect[0];
587 vertices[3].co[1] = rect[1]+rect[3];
588 vertices[3].uv[0] = uv[0];
589 vertices[3].uv[1] = uv[3];
590 vertices[3].colour = colour;
591 u16 ind_start = vg_uictx.cur_vert;
592
593 ui_rect_copy( vg_uictx.clipping, vertices[0].clip );
594 ui_rect_copy( vg_uictx.clipping, vertices[1].clip );
595 ui_rect_copy( vg_uictx.clipping, vertices[2].clip );
596 ui_rect_copy( vg_uictx.clipping, vertices[3].clip );
597
598 indices[0] = ind_start+0;
599 indices[1] = ind_start+2;
600 indices[2] = ind_start+1;
601
602 indices[3] = ind_start+0;
603 indices[4] = ind_start+3;
604 indices[5] = ind_start+2;
605
606 vg_uictx.cur_indice += 6;
607 vg_uictx.cur_vert += 4;
608
609 return vertices;
610 }
611
612 static struct ui_vert *ui_fill_rect( ui_rect rect, u32 colour )
613 {
614 return ui_fill_rect_uv( rect, colour, (ui_px[4]){ 4,4, 4,4 } );
615 }
616
617 static ui_px ui_text_line_offset( const char *str, ui_px scale,
618 enum ui_text_align align )
619 {
620 if( align == k_text_align_left )
621 return 0;
622
623 int length = 0;
624 const char *_c = str;
625 char c;
626
627 while( (c = *(_c ++)) )
628 if( c >= 32 && c <= 126 )
629 length ++;
630 else if( c == '\n' )
631 break;
632
633 if( align == k_text_align_right )
634 return -length * scale*8;
635 else
636 return (-length * scale*8) / 2;
637 }
638
639 VG_STATIC void ui_text( ui_px pos[2],
640 const char *str, ui_px scale, enum ui_text_align align )
641 {
642 ui_rect text_cursor;
643 u32 current_colour = 0x00ffffff;
644
645 const char *_c = str;
646 u8 c;
647
648 text_cursor[0] = pos[0] + ui_text_line_offset( str, scale, align );
649 text_cursor[1] = pos[1];
650 text_cursor[2] = 8*scale;
651 text_cursor[3] = 14*scale;
652
653 while( (c = *(_c ++)) ){
654 if( c == '\n' ){
655 text_cursor[1] += 14*scale;
656 text_cursor[0] = pos[0] + ui_text_line_offset( _c, scale, align );
657 continue;
658 }
659 else if( c >= 33 ){
660 u8 glyph_base[2];
661 u8 glyph_index = c;
662 glyph_base[0] = glyph_index & 0xf;
663 glyph_base[1] = (glyph_index-glyph_base[0])>>4;
664
665 glyph_base[0] *= 8;
666 glyph_base[1] *= 8;
667
668 ui_fill_rect_uv( text_cursor, current_colour, (ui_px[4])
669 {
670 glyph_base[0]+2,
671 glyph_base[1]+1,
672 glyph_base[0]+6,
673 glyph_base[1]+8
674 });
675 }
676 else if( c == '\x1B' ){
677 _c ++;
678 u16 colour_id = 0;
679 for( int i = 0; i < 3; i ++ ){
680 if( _c[i] ){
681 if( _c[i] == 'm' ){
682 _c = _c + i + 1;
683
684 switch( colour_id ){
685 case '0': current_colour = 0x00ffffff; break;
686 case '3'|'1'<<8: current_colour = 0x00201fee; break;
687 case '3'|'2'<<8: current_colour = 0x0037e420; break;
688 case '3'|'3'<<8: current_colour = 0x000ed8e2; break;
689 case '3'|'4'<<8: current_colour = 0x00f15010; break;
690 case '3'|'5'<<8: current_colour = 0x00ee20ee; break;
691 case '3'|'6'<<8: current_colour = 0x00eeee20; break;
692 case '3'|'7'<<8: current_colour = 0x00ffffff; break;
693 }
694
695 break;
696 }
697
698 colour_id |= _c[i] << (i*8);
699 }
700 else{
701 _c = _c +i;
702 break;
703 }
704 }
705
706 continue;
707 }
708 else if( c == '\t' ){
709 text_cursor[0] += UI_GLYPH_SPACING_X*scale*4;
710 continue;
711 }
712
713 text_cursor[0] += UI_GLYPH_SPACING_X*scale;
714 }
715 }
716
717 /*
718 * API Control
719 */
720 VG_STATIC void ui_begin( ui_px res_x, ui_px res_y )
721 {
722 vg_uictx.cursor[0] = 0;
723 vg_uictx.cursor[1] = 0;
724 vg_uictx.cursor[2] = res_x;
725 vg_uictx.cursor[3] = res_y;
726
727 ui_rect_copy( vg_uictx.cursor, vg_uictx.stack[0].rect );
728 vg_uictx.stack[0].mouse_over = 1;
729
730 vg_uictx.stack_count = 1;
731
732 vg_uictx.cur_vert = 0;
733 vg_uictx.cur_indice = 0;
734
735 ui_release_clip();
736
737 if( vg_uictx.click_state == 0 )
738 vg_uictx.capture_mouse_id = 0;
739
740 vg_uictx.image_count = 0;
741 }
742
743 VG_STATIC void ui_resolve(void)
744 {
745 if( vg_uictx.stack_count-1 )
746 {
747 vg_error( "[UI] Mismatched node create/drestroy!" );
748 return;
749 }
750
751 if( vg_uictx.click_state == 3 || vg_uictx.click_state == 0 )
752 {
753 vg_uictx.capture_lock = 0;
754 }
755 }
756
757 VG_STATIC void ui_set_mouse( int x, int y, int click_state )
758 {
759 vg_uictx.mouse[0] = x;
760 vg_uictx.mouse[1] = y;
761
762 vg_uictx.click_state = click_state;
763 }
764
765 /*
766 * High level controls
767 */
768 struct ui_window
769 {
770 const char *title;
771 ui_rect transform;
772
773 int drag;
774 ui_px drag_offset[2];
775 };
776
777 enum button_state
778 {
779 k_button_released = 0,
780 k_button_start_click,
781 k_button_click,
782 k_button_hold
783 };
784
785 static int ui_button(void)
786 {
787 u32 uid = vg_uictx.control_id ++;
788
789 ui_new_node();
790 {
791 ui_capture_mouse( uid );
792
793 if( ui_hasmouse() )
794 {
795 ui_fill_rect( vg_uictx.cursor, vg_uictx.colours->hover );
796
797 if( vg_uictx.click_state == 1 )
798 {
799 vg_uictx.capture_lock = 1;
800 return k_button_start_click;
801 }
802 else if( vg_uictx.capture_lock && vg_uictx.click_state == 3 )
803 return k_button_click;
804 else if( vg_uictx.capture_lock && vg_uictx.click_state == 2 )
805 return k_button_hold;
806
807 return k_button_click;
808 }
809 else
810 ui_fill_rect( vg_uictx.cursor, vg_uictx.colours->main );
811 }
812
813 return k_button_released;
814 }
815
816 static int ui_window( struct ui_window *window, u32 control_group )
817 {
818 if( window->drag )
819 {
820 window->transform[0] = vg_uictx.mouse[0]+window->drag_offset[0];
821 window->transform[1] = vg_uictx.mouse[1]+window->drag_offset[1];
822
823 ui_clamp_rect( vg_uictx.stack[0].rect, window->transform );
824
825 if( vg_uictx.click_state == 0 || vg_uictx.click_state == 3 )
826 {
827 window->drag = 0;
828 }
829 }
830
831 ui_rect_copy( window->transform, vg_uictx.cursor );
832
833 ui_new_node();
834 {
835 ui_capture_mouse( vg_uictx.control_id ++ );
836
837 /* Drag bar */
838 vg_uictx.cursor[3] = 25;
839 ui_new_node();
840 {
841 ui_capture_mouse( vg_uictx.control_id ++ );
842
843 struct ui_vert *drag_bar = ui_fill_rect( vg_uictx.cursor, 0xff555555 );
844
845 /* title.. */
846 vg_uictx.cursor[0] += 2;
847 vg_uictx.cursor[1] += 2;
848 ui_text( vg_uictx.cursor, window->title, 2, 0 );
849
850 /* Close button */
851 vg_uictx.cursor[3] = 25;
852 vg_uictx.cursor[2] = 25;
853 ui_align_right();
854 ui_align_top();
855 ui_rect_pad( vg_uictx.cursor, 4 );
856
857 if( ui_button() )
858 {
859 vg_info( "Click clacked\n" );
860 }
861 vg_uictx.cursor[0] += 2;
862 ui_text( vg_uictx.cursor, "x", 2, 0 );
863 ui_end();
864
865 if( ui_hasmouse() )
866 {
867 drag_bar[0].colour = 0xff777777;
868 drag_bar[1].colour = 0xff777777;
869 drag_bar[2].colour = 0xff777777;
870 drag_bar[3].colour = 0xff777777;
871
872 /* start drag */
873 if( vg_uictx.click_state == 1 )
874 {
875 window->drag = 1;
876 window->drag_offset[0] = window->transform[0]-vg_uictx.mouse[0];
877 window->drag_offset[1] = window->transform[1]-vg_uictx.mouse[1];
878 }
879 }
880 }
881 ui_end_down();
882 }
883
884 return 1;
885 }
886
887 VG_STATIC void ui_push_image( ui_rect rc, GLuint image )
888 {
889 struct ui_image *img = &vg_uictx.images[ vg_uictx.image_count ++ ];
890 ui_rect_copy( rc, img->rc );
891 img->image = image;
892 }
893
894 struct ui_slider
895 {
896 float *data;
897 float min, max;
898 };
899
900 struct ui_slider_vector
901 {
902 float *data, min, max;
903 struct ui_slider sub[4];
904 u32 len;
905 };
906
907 struct ui_checkbox
908 {
909 int *data;
910 };
911
912 VG_STATIC void ui_slider( struct ui_slider *slider )
913 {
914 ui_new_node();
915
916 ui_px slider_start = vg_uictx.cursor[0];
917
918 float const ftotal = vg_uictx.cursor[2],
919 fwidth = ftotal*0.25f,
920 fmove = ftotal - fwidth,
921 fstart = fwidth*0.5f,
922 frange = slider->max-slider->min,
923 fpos = (*slider->data - slider->min) / frange;
924
925 ui_fill_rect( vg_uictx.cursor, 0xff111111 );
926 vg_uictx.cursor[2] = fwidth;
927 vg_uictx.cursor[0] = slider_start + fpos * fmove;
928
929 u32 uid = vg_uictx.control_id ++;
930 int status = ui_button();
931 if( vg_uictx.capture_lock && (vg_uictx.capture_mouse_id == uid))
932 {
933 float ui_new = vg_uictx.mouse[0],
934 local = ui_new - (slider_start + fstart),
935 zo = vg_clampf(local / fmove,0.0f,1.0f);
936
937 *slider->data = vg_lerpf( slider->min, slider->max, zo );
938 }
939
940 vg_uictx.cursor[0] += 4;
941 vg_uictx.cursor[1] += 4;
942
943 char buf[12];
944 snprintf( buf, 12, "%.2f", *slider->data );
945 ui_text( vg_uictx.cursor, buf, 1, 0 );
946 ui_end_down();
947 ui_end_down();
948 }
949
950 VG_STATIC void ui_slider_vector( struct ui_slider_vector *slider )
951 {
952 for( int i=0; i<slider->len; i++ )
953 {
954 slider->sub[i].data = &slider->data[i];
955 slider->sub[i].min = slider->min;
956 slider->sub[i].max = slider->max;
957 ui_slider( &slider->sub[i] );
958 }
959 }
960
961 VG_STATIC void ui_checkbox( struct ui_checkbox *cb )
962 {
963 if( ui_button() == k_button_click )
964 *cb->data ^= 0x1;
965
966 ui_new_node();
967 ui_rect_pad( vg_uictx.cursor, 4 );
968 if( *cb->data )
969 ui_fill_rect( vg_uictx.cursor, 0xff00e052 );
970 else
971 ui_fill_rect( vg_uictx.cursor, 0xff0052e0 );
972
973 ui_end();
974 ui_end_down();
975 }
976
977 #endif /* VG_UI_H */