YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleaned up some UI code.

Browse Source
This commit is contained in:
Dominic Masters
2021-09-12 13:01:20 -07:00
parent ecd5c0c47c
commit 8d69d12728
21 changed files with 74 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -20,7 +20,7 @@ set(SETTING_GAME_POKER 1)
set(SETTING_GAME_DAWN 2)
set(SETTING_GAME_SANDBOX 3)
set(SETTING_GAME SETTING_GAME_SANDBOX)
set(SETTING_GAME SETTING_GAME_POKER)
set(SETTING_GAME_NAME "DawnGame")
################################## Targets #####################################

5
include/dawn/dawn.h
View File

@ -77,13 +77,10 @@
#include "ui/grid.h"
#include "ui/image.h"
#include "ui/label.h"
#include "ui/menuv2.h"
#include "ui/menu.h"
#include "ui/rectangle.h"
#include "ui/textmenu.h"
#include "ui/menu.h"
#include "ui/menulist.h"
// Utility Objects
#include "util/array.h"
#include "util/dynarray.h"

26
include/dawn/ui/menu.h
View File

@ -7,31 +7,17 @@
#pragma once
#include "../libs.h"
#include "grid.h"
/** The maximum number of items a menu can hold */
#define MENU_ITEMS_MAX 32
/** Generic callback for menu events */
typedef void menucallback_t(void *user, uint8_t i);
typedef struct _menuitem_t menuitem_t;
typedef struct _menu_t menu_t;
/** Callback for when menu events are fired. */
typedef void menucallback_t(menu_t *m, menuitem_t *t, uint8_t i, void *user);
typedef struct _menuitem_t {
uint8_t x;
uint8_t y;
uint8_t width;
uint8_t height;
} menuitem_t;
typedef struct _menu_t {
menuitem_t items[MENU_ITEMS_MAX];
uint8_t itemCount;
/** Structure for a menu */
typedef struct {
grid_t grid;
uint8_t selected;
uint8_t cursorX;
uint8_t cursorY;
void *user;
menucallback_t *onSelect;
} menu_t;

35
include/dawn/ui/menulist.h
View File

@ -1,35 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "frame.h"
#include "label.h"
#include "menu.h"
#include "rectangle.h"
/** Color of the menulist selection rectangle */
#define MENULIST_SELECTION_COLOR ((pixel_t){ .r=255, .g=255, .b=255, .a=150 })
/** Maximum number of items that the list supports */
#define MENULIST_ITEMS_MAX 32
typedef struct _menulist_t menulist_t;
/** Callback for when a menulist item is selected */
typedef void menulistcallback_t(menulist_t *list, uint8_t i, void *user);
/** Representation of a menu list, a menu with multiple menu items. */
typedef struct _menulist_t {
char *items[MENULIST_ITEMS_MAX];
label_t labels[MENULIST_ITEMS_MAX];
frame_t frame;
menu_t menu;
rectangle_t selection;
menulistcallback_t *onSelect;
void *user;
} menulist_t;

23
include/dawn/ui/menuv2.h
View File

@ -1,23 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "grid.h"
/** Generic callback for menu events */
typedef void menuv2callback_t(void *user, uint8_t i);
/** Structure for a menu */
typedef struct {
grid_t grid;
uint8_t selected;
uint8_t cursorX;
uint8_t cursorY;
void *user;
menuv2callback_t *onSelect;
} menuv2_t;

6
include/dawn/ui/textmenu.h
View File

@ -6,11 +6,13 @@
#pragma once
#include "../libs.h"
#include "../display/font.h"
#include "menuv2.h"
#include "menu.h"
#include "grid.h"
#include "label.h"
#include "rectangle.h"
#define TEXTMENU_SELECTION_COLOR ((pixel_t){.r=0xFF,.g=0xFF,.b=0xFF,.a=0x64})
typedef void textmenucallback_t(void *user, uint8_t i, char *text);
typedef struct {
@ -19,7 +21,7 @@ typedef struct {
} textmenulabelinfo_t;
typedef struct {
menuv2_t menu;
menu_t menu;
char *texts[GRID_CHILD_COUNT];
font_t *font;

6
src/file/asset.c
View File

@ -131,3 +131,9 @@ void assetFontLoad(font_t *font, char *assetName) {
fontInit(font, data);
free(data);
}
void assetXmlLoad(xml_t *xml, char *assetName) {
char *data = assetStringLoad(assetName);
xmlLoad(xml, data);
free(data);
}

1
src/file/asset.h
View File

@ -10,6 +10,7 @@
#include "../display/shader.h"
#include "../display/texture.h"
#include "../display/font.h"
#include "xml.h"
/**
* Method to load an asset into memory as a raw string.

6
src/file/xml.c
View File

@ -158,6 +158,7 @@ int32_t xmlLoadChild(xml_t *xml, char *data, int32_t i) {
doing = XML_DOING_NOTHING;
//TODO: Return index or something?
free(buffer);
return i;
break;
@ -166,6 +167,8 @@ int32_t xmlLoadChild(xml_t *xml, char *data, int32_t i) {
break;
}
}
free(buffer);
}
void xmlLoad(xml_t *xml, char *data) {
@ -180,6 +183,9 @@ void xmlDispose(xml_t *xml) {
xmlDispose(xml->children + i);
}
// Free children array.
free(xml->children);
// Dispose attributes
for(i = 0; i < xml->attributeCount; i++) {
free(xml->attributeNames + i);

11
src/game/sandbox/sandboxscene.c
View File

@ -16,17 +16,6 @@ bool sandboxSceneInit(sandboxscene_t *game) {
"shaders/textured.vert", "shaders/textured.frag"
);
xml_t xml;
xmlLoad(&xml, "<a><b>Hello World</b><b>Hello Bruh</b></a>", 0);
for(uint8_t i = 0; i < xml.childrenCount; i++) {
printf("Value: %s\n", xml.children[i].value);
}
framedTextMenuInit(&menu, &game->font, &game->texture);
gridAddBreakpoint(&menu.menu.menu.grid, -1, 2, 3, 0, 0);

2
src/game/sandbox/sandboxscene.h
View File

@ -20,7 +20,7 @@
#include "../../file/xml.h"
#include "../../ui/grid.h"
#include "../../ui/menuv2.h"
#include "../../ui/menu.h"
#include "../../ui/textmenu.h"
#include "../../ui/framedtextmenu.h"

2
src/ui/framedtextmenu.c
View File

@ -56,7 +56,7 @@ void framedTextMenuUpdate(framedtextmenu_t *menu, engine_t *engine) {
iw, ih,
0, 0
);
menu2Update(&menu->menu.menu, engine);
menuUpdate(&menu->menu.menu, engine);
}
void framedTextMenuRender(

1
src/ui/framedtextmenu.h
View File

@ -10,6 +10,7 @@
#include "frame.h"
#include "textmenu.h"
#include "grid.h"
#include "menu.h"
/**
* Initialize a framed text ui element.

63
src/ui/menu.c
View File

@ -8,28 +8,33 @@
#include "menu.h"
void menuInit(menu_t *menu) {
menu->itemCount = 0;
menu->selected = 0;
gridInit(&menu->grid);
menu->grid.user = menu;
menu->cursorX = 0;
menu->cursorY = 0;
menu->selected = 0;
menu->user = NULL;
menu->onSelect = NULL;
}
void menuUpdate(menu_t *menu, engine_t *engine) {
menuitem_t *current;
menuitem_t *item;
uint8_t x, y, i, j;
uint8_t x, y, i, j, cx, cy;
gridchild_t *current;
gridchildbreakpoint_t *currentbp;
gridchild_t *item;
gridchildbreakpoint_t *itembp;
current = menu->items + menu->selected;
current = menu->grid.children + menu->selected;
currentbp = gridChildGetBreakpoint(current, menu->grid.breakpointCurrent);
if(inputIsPressed(&engine->input, INPUT_ACCEPT)) {
if(menu->onSelect != NULL) {
menu->onSelect(menu, current, menu->selected, menu->user);
}
if(menu->onSelect != NULL) menu->onSelect(menu->user, menu->selected);
return;
}
// Handle press binds.
if(inputIsPressed(&engine->input, INPUT_DOWN)) {
x = 0;
@ -48,29 +53,35 @@ void menuUpdate(menu_t *menu, engine_t *engine) {
y = 0;
}
// Update cursor positions
if(x != 0 || y != 0) {
if(x > 0) {
menu->cursorX = (current->x + current->width - 1) + x;
cx = (currentbp->x + currentbp->columns - 1) + x;
} else if(x < 0) {
menu->cursorX = current->x + x;
cx = currentbp->x + x;
} else {
cx = menu->cursorX;
}
if(y > 0) {
menu->cursorY = (current->y + current->height - 1) + y;
cy = (currentbp->y + currentbp->rows - 1) + y;
} else if(y < 0) {
menu->cursorY = current->y + y;
cy = currentbp->y + y;
} else {
cy = menu->cursorY;
}
// Get the item selected
j = MENU_ITEMS_MAX;
for(i = 0; i < menu->itemCount; i++) {
j = GRID_CHILD_COUNT;
for(i = 0; i < menu->grid.childCount; i++) {
if(i == menu->selected) continue;
item = menu->items + i;
item = menu->grid.children + i;
itembp = gridChildGetBreakpoint(item, menu->grid.breakpointCurrent);
if(
item->x > menu->cursorX || (item->x+item->width-1) < menu->cursorX ||
item->y > menu->cursorY || (item->y+item->height-1) < menu->cursorY
itembp->x > cx || (itembp->x + itembp->columns - 1) < cx ||
itembp->y > cy || (itembp->y + itembp->rows - 1) < cy
) continue;
j = i;
@ -78,19 +89,9 @@ void menuUpdate(menu_t *menu, engine_t *engine) {
}
// Was a target found?
if(j == MENU_ITEMS_MAX) return;
if(j == GRID_CHILD_COUNT) return;
menu->cursorX = cx;
menu->cursorY = cy;
menu->selected = j;
}
}
menuitem_t * menuAdd(menu_t *menu) {
menuitem_t *item = menu->items + menu->itemCount;
item->x = 0;
item->y = 0;
item->width = 1;
item->height = 1;
menu->itemCount++;
return item;
}

21
src/ui/menu.h
View File

@ -7,31 +7,20 @@
#pragma once
#include <dawn/dawn.h>
#include "grid.h"
#include "../input/input.h"
#include "../epoch/epoch.h"
#include "../util/array.h"
/**
* Initialize a menu.
* Initialize a Menu UI component.
*
* @param menu Menu to initialize.
* @param columns Count of rows.
* @param rows Count of columns.
*/
void menuInit(menu_t *menu);
/**
* Updates the menu to handle inputs.
* Update a Menu UI Component
*
* @param menu Menu to update.
* @param engine Engine to update from.
* @param menu Menu to update
* @param engine Engine to use during the update.
*/
void menuUpdate(menu_t *menu, engine_t *engine);
/**
* Add an item to the menu
*
* @param menu Menu to add to.
* @return Item to add to.
*/
menuitem_t * menuAdd(menu_t *menu);

101
src/ui/menulist.c
View File

@ -1,101 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "menulist.h"
void _menuListMenuOnSelect(menu_t *menu, menuitem_t *item, uint8_t i, void *u) {
menulist_t *ml = (menulist_t *)u;
if(ml->onSelect == NULL) return;
ml->onSelect(ml, i, ml->user);
}
void menuListInit(menulist_t *ml, texture_t *texture) {
ml->onSelect = NULL;
// Initialize menu
menuInit(&ml->menu);
ml->menu.onSelect = &_menuListMenuOnSelect;
ml->menu.user = (void *)ml;
// Init the selection rectangle
rectangleInit(&ml->selection);
rectangleSetColor(&ml->selection, MENULIST_SELECTION_COLOR);
// Init the frame
frameInit(&ml->frame);
ml->frame.texture = texture;
}
uint8_t menuListAdd(menulist_t *ml, font_t *font, char *text) {
uint8_t i;
label_t *label;
menuitem_t *item;
// Get the variables.
i = ml->menu.itemCount;
label = ml->labels + i;
ml->items[i] = text;
// Initialize the label.
labelInit(label);
labelSetText(label, font, text);
// Reize the frame
frameSetInnerSize(
&ml->frame,
100,
FONT_LINE_HEIGHT * fontGetScale(label->fontSize) * (i+1)
);
// Add Menu Item
item = menuAdd(&ml->menu);
item->width = 1;
item->height = 1;
item->x = 0;
item->y = i;
return i;
}
void menuListUpdate(menulist_t *ml, engine_t *engine) {
menuUpdate(&ml->menu, engine);
}
void menuListRender(menulist_t *ml, shader_t *shader, float x, float y) {
uint8_t i;
float fontScale;
fontScale = fontGetScale(ml->labels->fontSize);
// Render the frame
frameRender(&ml->frame, shader, x, y);
// Render selection box.
ml->selection.width = 100;
ml->selection.height = FONT_LINE_HEIGHT * fontScale;
rectangleRender(&ml->selection, shader,
x + FRAME_BORDER_SIZE,
y + FRAME_BORDER_SIZE +ml->menu.selected * FONT_LINE_HEIGHT * fontScale
);
// Render each label.
for(i = 0; i < ml->menu.itemCount; i++) {
labelRender(ml->labels + i, shader,
FRAME_BORDER_SIZE,
FRAME_BORDER_SIZE + i * FONT_LINE_HEIGHT * fontScale
);
}
}
void menuListDispose(menulist_t *ml) {
uint8_t i;
for(i = 0; i < ml->menu.itemCount; i++) {
labelDispose(ml->labels + i);
}
frameDispose(&ml->frame);
}

59
src/ui/menulist.h
View File

@ -1,59 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "label.h"
#include "menu.h"
#include "frame.h"
#include "rectangle.h"
/** Callback to listen for when the menu is selected. */
void _menuListMenuOnSelect(menu_t *menu, menuitem_t *item, uint8_t i, void *u);
/**
* Initialize a menu list.
*
* @param ml Menu List to initialize.
* @param texture Texture to use for the frame.
*/
void menuListInit(menulist_t *ml, texture_t *texture);
/**
* Add an item to the menu list.
*
* @param ml Menu list to add to.
* @param font Font to use for the label.
* @param text Text to add.
* @return Index that refers to the label/menu item.
*/
uint8_t menuListAdd(menulist_t *ml, font_t *font, char *text);
/**
* Tick the menu list and listen for input changes.
*
* @param ml Menu list to update.
* @param engine Engine to update with.
*/
void menuListUpdate(menulist_t *ml, engine_t *engine);
/**
* Render a menu list.
*
* @param ml Menu list to render.
* @param shader Shader to use.
* @param x X position.
* @param y Y position.
*/
void menuListRender(menulist_t *ml, shader_t *shader, float x, float y);
/**
* Cleanup a previously created menu list.
*
* @param ml Menu list to clean up.
*/
void menuListDispose(menulist_t *ml);

97
src/ui/menuv2.c
View File

@ -1,97 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "menuv2.h"
void menu2Init(menuv2_t *menu) {
gridInit(&menu->grid);
menu->grid.user = menu;
menu->cursorX = 0;
menu->cursorY = 0;
menu->selected = 0;
menu->user = NULL;
menu->onSelect = NULL;
}
void menu2Update(menuv2_t *menu, engine_t *engine) {
uint8_t x, y, i, j, cx, cy;
gridchild_t *current;
gridchildbreakpoint_t *currentbp;
gridchild_t *item;
gridchildbreakpoint_t *itembp;
current = menu->grid.children + menu->selected;
currentbp = gridChildGetBreakpoint(current, menu->grid.breakpointCurrent);
if(inputIsPressed(&engine->input, INPUT_ACCEPT)) {
if(menu->onSelect != NULL) menu->onSelect(menu->user, menu->selected);
return;
}
// Handle press binds.
if(inputIsPressed(&engine->input, INPUT_DOWN)) {
x = 0;
y = 1;
} else if(inputIsPressed(&engine->input, INPUT_UP)) {
x = 0;
y = -1;
} else if(inputIsPressed(&engine->input, INPUT_LEFT)) {
x = -1;
y = 0;
} else if(inputIsPressed(&engine->input, INPUT_RIGHT)) {
x = 1;
y = 0;
} else {
x = 0;
y = 0;
}
// Update cursor positions
if(x != 0 || y != 0) {
if(x > 0) {
cx = (currentbp->x + currentbp->columns - 1) + x;
} else if(x < 0) {
cx = currentbp->x + x;
} else {
cx = menu->cursorX;
}
if(y > 0) {
cy = (currentbp->y + currentbp->rows - 1) + y;
} else if(y < 0) {
cy = currentbp->y + y;
} else {
cy = menu->cursorY;
}
// Get the item selected
j = GRID_CHILD_COUNT;
for(i = 0; i < menu->grid.childCount; i++) {
if(i == menu->selected) continue;
item = menu->grid.children + i;
itembp = gridChildGetBreakpoint(item, menu->grid.breakpointCurrent);
if(
itembp->x > cx || (itembp->x + itembp->columns - 1) < cx ||
itembp->y > cy || (itembp->y + itembp->rows - 1) < cy
) continue;
j = i;
break;
}
// Was a target found?
if(j == GRID_CHILD_COUNT) return;
menu->cursorX = cx;
menu->cursorY = cy;
menu->selected = j;
}
}

15
src/ui/menuv2.h
View File

@ -1,15 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "grid.h"
#include "../input/input.h"
void menu2Init(menuv2_t *menu);
void menu2Update(menuv2_t *menu, engine_t *engine);

8
src/ui/textmenu.c
View File

@ -7,7 +7,7 @@
#include "textmenu.h"
void _textMenuOnSelect(menuv2_t *menu, uint8_t i) {
void _textMenuOnSelect(menu_t *menu, uint8_t i) {
textmenu_t *textMenu = (textmenu_t *)menu->user;
if(textMenu->onSelect != NULL) {
@ -21,7 +21,7 @@ void _textMenuOnResize(
float x, float y,
float width, float height
) {
textmenu_t *textMenu = (textmenu_t *)((menuv2_t *)user);
textmenu_t *textMenu = (textmenu_t *)((menu_t *)user);
label_t *label = textMenu->labels + i;
textmenulabelinfo_t *info = textMenu->labelInfo + i;
info->x = x;
@ -33,9 +33,9 @@ void _textMenuOnResize(
}
void textMenuInit(textmenu_t *menu, font_t *font) {
menu2Init(&menu->menu);
menuInit(&menu->menu);
rectangleInit(&menu->rectangle);
rectangleSetColor(&menu->rectangle, MENULIST_SELECTION_COLOR);
rectangleSetColor(&menu->rectangle, TEXTMENU_SELECTION_COLOR);
menu->menu.user = menu;
menu->menu.onSelect = &_textMenuOnSelect;

6
src/ui/textmenu.h
View File

@ -7,17 +7,17 @@
#pragma once
#include <dawn/dawn.h>
#include "menuv2.h"
#include "menu.h"
#include "grid.h"
#include "label.h"
#include "rectangle.h"
/** Callback to be notified from the menu when the menu items are selected. */
void _textMenuOnSelect(menuv2_t *menu, uint8_t i);
void _textMenuOnSelect(menu_t *menu, uint8_t i);
/** Callback to lisen for resize events from the grid subsystem */
void _textMenuOnResize(
void *user, uint8_t i,
void *user, uint8_t i, gridchildbreakpoint_t *breakpoint,
float screenWidth, float screenHeight,
float x, float y,
float width, float height