fork/training-mode-ce

git clone https://git.julia.blue/fork/training-mode-ce

Alex Harrisonfix console crash by removing defuct scrolloff check (Why was this line causing a console crash??? It's not even run on boot!)2bacb35

master
20.7 KiB613 linesraw
1#include "events.h"
2
3GOBJ *EventMenu_Init(EventMenu *start_menu)
4{
5    // Ensure this event has a menu
6    if (start_menu == 0)
7        assert("No menu");
8
9    // Create a cobj for the event menu
10    COBJDesc ***dmgScnMdls = Archive_GetPublicAddress(*stc_ifall_archive, (void *)0x803f94d0);
11    COBJDesc *cam_desc = dmgScnMdls[1][0];
12    COBJ *cam_cobj = COBJ_LoadDesc(cam_desc);
13    GOBJ *cam_gobj = GObj_Create(19, 20, 0);
14    GObj_AddObject(cam_gobj, R13_U8(-0x3E55), cam_cobj);
15    GOBJ_InitCamera(cam_gobj, CObjThink_Common, MENUCAM_GXPRI);
16    cam_gobj->cobj_links = MENUCAM_COBJGXLINK;
17
18    GOBJ *gobj = GObj_Create(0, 0, 0);
19    MenuData *menu_data = calloc(sizeof(MenuData));
20    GObj_AddUserData(gobj, 4, HSD_Free, menu_data);
21
22    GObj_AddGXLink(gobj, GXLink_Common, GXLINK_MENUMODEL, GXPRI_MENUMODEL);
23
24    // TODO remove popup canvas ussage in lab.c
25    menu_data->canvas_menu = Text_CreateCanvas(2, cam_gobj, 9, 13, 0, GXLINK_MENUTEXT, GXPRI_MENUTEXT, MENUCAM_GXPRI);
26    menu_data->canvas_popup = Text_CreateCanvas(2, cam_gobj, 9, 13, 0, GXLINK_MENUTEXT, GXPRI_POPUPTEXT, MENUCAM_GXPRI);
27    menu_data->curr_menu = start_menu;
28
29    EventMenu_CreateModel(gobj);
30    EventMenu_CreateText(gobj);
31    menu_data->hide_menu = 1;
32
33    return gobj;
34};
35
36void EventMenu_EnterMenu(GOBJ *gobj) {
37    MenuData *menu_data = gobj->userdata;
38
39    menu_data->mode = MenuMode_Paused;
40    EventMenu_UpdateText(gobj);
41
42    // Speed up repeat behavior
43    stc_padlibdata->repeat_interval = MENU_RAPID_INTERVAL; // default is 8
44    stc_padlibdata->repeat_start = MENU_RAPID_START;       // default is 45
45
46    // Freeze the game
47    Match_FreezeGame(1);
48    SFX_PlayCommon(5);
49    Match_HideHUD();
50    Match_AdjustSoundOnPause(1);
51}
52
53void EventMenu_ExitMenu(GOBJ *gobj) {
54    MenuData *menu_data = gobj->userdata;
55
56    menu_data->mode = MenuMode_Normal;
57    menu_data->hide_menu = 1;
58
59    // Allow the custom submenu to clean itself up before we exit
60    if (menu_data->custom_gobj_destroy) {
61        menu_data->custom_gobj_destroy(menu_data->custom_gobj);
62        menu_data->custom_gobj = 0;
63        menu_data->custom_gobj_think = 0;
64        menu_data->custom_gobj_destroy = 0;
65    }
66
67    // Reset repeat behavior
68    stc_padlibdata->repeat_interval = stc_default_padlibdata->repeat_interval;
69    stc_padlibdata->repeat_start = stc_default_padlibdata->repeat_start;
70
71    // Unfreeze the game
72    Match_UnfreezeGame(1);
73    Match_ShowHUD();
74    Match_AdjustSoundOnPause(0);
75}
76
77void EventMenu_PrevMenu(GOBJ *gobj) {
78    MenuData *menu_data = gobj->userdata;
79    EventMenu *curr_menu = menu_data->curr_menu;
80
81    if (!curr_menu->prev)
82        assert("No previous menu");
83
84    // reset cursor so it starts at top on reentry
85    curr_menu->scroll = 0;
86    curr_menu->cursor = 0;
87
88    curr_menu = curr_menu->prev;
89    menu_data->curr_menu = curr_menu;
90
91    EventMenu_UpdateText(gobj);
92}
93
94void EventMenu_NextMenu(GOBJ *gobj, EventMenu* next_menu) {
95    MenuData *menu_data = gobj->userdata;
96
97    if (!next_menu)
98        assert("Missing next menu");
99
100    // Propogate shortcuts forward from the base menu. Kinda hacky for now.
101    next_menu->shortcuts = menu_data->curr_menu->shortcuts;
102    next_menu->prev = menu_data->curr_menu;
103    menu_data->curr_menu = next_menu;
104
105    EventMenu_UpdateText(gobj);
106}
107
108void EventMenu_ChangeOptionVal(GOBJ *gobj, EventOption* option, int val) {
109    switch(option->kind) {
110        case OPTKIND_STRING:
111        case OPTKIND_INT:
112            if (val < option->value_min || val - option->value_min >= option->value_num)
113                assert("Illegal option value");
114            break;
115        case OPTKIND_TOGGLE:
116            if (val != 0 && val != 1)
117                assert("Illegal option value");
118            break;
119        default:
120            assert("Option kind has no value");
121            break;
122    }
123
124    option->val_prev = option->val;
125    option->val = val;
126    if (option->OnChange)
127        option->OnChange(event_vars->menu_gobj, val);
128
129    EventMenu_UpdateText(gobj);
130}
131
132void EventMenu_Update(GOBJ *gobj)
133{
134    MenuData *menu_data = gobj->userdata;
135    EventMenu *curr_menu = menu_data->curr_menu;
136
137    bool pause_pressed = false;
138    int pause_index = 0;
139    for (int i = 0; i < 4; i++) {
140        HSD_Pad *pad = PadGetMaster(i);
141        if (pad->down & HSD_BUTTON_START) {
142            pause_pressed = true;
143            pause_index = i;
144            break;
145        }
146    }
147
148    if (menu_data->mode == MenuMode_Normal) {
149        if(pause_pressed) {
150            EventMenu_EnterMenu(gobj);
151            menu_data->controller_index = pause_index;
152        }
153        return;
154    }
155    if (menu_data->custom_gobj_think) {
156        // We delegate to the custom_gobj if it exists. custom_gobj_think
157        // returns nonzero when it allows unpause. While delegating we hide the
158        // menu
159        menu_data->hide_menu = 1;
160        if(menu_data->custom_gobj_think(menu_data->custom_gobj) && pause_pressed)
161            EventMenu_ExitMenu(gobj);
162        return;
163    }
164    if (pause_pressed) { //TODO maybe some future modes won't allow unpause
165        EventMenu_ExitMenu(gobj);
166        return;
167    }
168
169    menu_data->hide_menu = 0;
170    HSD_Pad *pad = PadGetMaster(menu_data->controller_index);
171
172    if ((pad->held & HSD_BUTTON_Y) && menu_data->curr_menu->shortcuts) {
173        ShortcutList *shortcuts = menu_data->curr_menu->shortcuts;
174        for (int i = 0; i < shortcuts->count; ++i) {
175            Shortcut *shortcut = shortcuts->list + i;
176            if (!shortcut || !shortcut->option || !shortcut->button_mask)
177                assert("Invalid shortcut definition");
178            if (pad->down & shortcut->button_mask) {
179                EventOption *option = shortcut->option;
180
181                if (option->disable) {
182                    SFX_PlayCommon(4);
183                    continue;
184                }
185
186                if (option->kind == OPTKIND_TOGGLE) {
187                    EventMenu_ChangeOptionVal(gobj, option, !option->val);
188                    SFX_PlayCommon(option->val ? 2 : 0);
189                }
190                else if (option->kind == OPTKIND_STRING || option->kind == OPTKIND_INT) {
191                    int val = (option->val + 1 - option->value_min) % option->value_num + option->value_min;
192                    EventMenu_ChangeOptionVal(gobj, option, val);
193                    SFX_PlayCommon(2);
194                }
195                else if (option->kind == OPTKIND_MENU) {
196                    if (menu_data->curr_menu == option->menu)
197                        continue;
198                    // rewind to top level menu before going to the next menu
199                    while (menu_data->curr_menu->prev) {
200                        EventMenu_PrevMenu(gobj);
201                    }
202                    EventMenu_NextMenu(gobj, option->menu);
203                    SFX_PlayCommon(1);
204                    EventMenu_UpdateText(gobj);
205                }
206                else {
207                    assert("Invalid shortcut option kind");
208                }
209
210                break;
211            }
212        }
213    } else if (menu_data->mode == MenuMode_Paused) {
214        EventMenu_MenuThink(gobj, curr_menu);
215    }
216}
217
218void EventMenu_MenuGX(GOBJ *gobj, int pass)
219{
220    MenuData *menu_data = event_vars->menu_gobj->userdata;
221    if (!menu_data->hide_menu)
222        GXLink_Common(gobj, pass);
223}
224
225void EventMenu_TextGX(GOBJ *gobj, int pass)
226{
227    MenuData *menu_data = event_vars->menu_gobj->userdata;
228    if (!menu_data->hide_menu)
229        Text_GX(gobj, pass);
230}
231
232void EventMenu_MenuThink(GOBJ *gobj, EventMenu *curr_menu) {
233    MenuData *menu_data = gobj->userdata;
234
235    HSD_Pad *pad = PadGetMaster(menu_data->controller_index);
236    int inputs = pad->repeat;
237
238    // Speed up scrolling when R is held
239    if ((pad->held & HSD_TRIGGER_R)
240        || pad->triggerRight >= ANALOG_TRIGGER_THRESHOLD) {
241        if (pad->repeat_timer > MENU_RAPID_R)
242            pad->repeat_timer = MENU_RAPID_R;
243    }
244
245    // get menu variables
246    s32 cursor = curr_menu->cursor;
247    s32 scroll = curr_menu->scroll;
248    EventOption *curr_option = &curr_menu->options[cursor + scroll];
249
250    if (inputs & (HSD_BUTTON_DOWN | HSD_BUTTON_DPAD_DOWN)) {
251        // loop to find next option
252        int cursor_next = 0; // how much to move the cursor by
253        for (int i = 1; (cursor + scroll + i) < curr_menu->option_num; i++) {
254            // option exists, check if it's enabled
255            if (curr_menu->options[cursor + scroll + i].disable == 0) {
256                cursor_next = i;
257                break;
258            }
259        }
260        if (cursor_next == 0)
261            return;
262
263        cursor += cursor_next;
264
265        // If cursor went too far down, scroll down to compensate
266        if (cursor >= MENU_MAXOPTION - MENU_SCROLLOFF) {
267            int max_scroll = curr_menu->option_num - MENU_MAXOPTION - scroll;
268            int want_scroll = cursor - MENU_MAXOPTION + MENU_SCROLLOFF + 1;
269            int delta_scroll = min(want_scroll, max_scroll);
270
271            scroll += delta_scroll;
272            cursor -= delta_scroll;
273        }
274
275        curr_menu->cursor = cursor;
276        curr_menu->scroll = scroll;
277
278        EventMenu_UpdateText(gobj);
279        SFX_PlayCommon(2);
280    }
281    else if (inputs & (HSD_BUTTON_UP | HSD_BUTTON_DPAD_UP)) {
282        // loop to find next option
283        int cursor_next = 0; // how much to move the cursor by
284        for (int i = 1; (cursor + scroll - i) >= 0; i++) {
285            // option exists, check if it's enabled
286            if (curr_menu->options[cursor + scroll - i].disable == 0) {
287                cursor_next = i;
288                break;
289            }
290        }
291        if (cursor_next == 0)
292            return;
293
294        cursor -= cursor_next;
295
296        // If cursor went too far up, scroll up to compensate
297        if (cursor < MENU_SCROLLOFF) {
298            int delta_scroll = min(MENU_SCROLLOFF - cursor, scroll);
299
300            scroll -= delta_scroll;
301            cursor += delta_scroll;
302        }
303        curr_menu->cursor = cursor;
304        curr_menu->scroll = scroll;
305
306        EventMenu_UpdateText(gobj);
307        SFX_PlayCommon(2);
308    }
309    else if (inputs & HSD_BUTTON_B && curr_menu->prev)
310    {
311        EventMenu_PrevMenu(gobj);
312        SFX_PlayCommon(0);
313    }
314    else if (curr_option->kind == OPTKIND_TOGGLE &&
315            inputs & (HSD_BUTTON_LEFT | HSD_BUTTON_DPAD_LEFT
316                | HSD_BUTTON_RIGHT | HSD_BUTTON_DPAD_RIGHT
317                | HSD_BUTTON_A)) {
318        EventMenu_ChangeOptionVal(gobj, curr_option, !curr_option->val);
319        SFX_PlayCommon(2);
320    }
321    else if (inputs & (HSD_BUTTON_LEFT | HSD_BUTTON_DPAD_LEFT))
322    {
323        if ((curr_option->kind == OPTKIND_STRING || curr_option->kind == OPTKIND_INT)
324                && curr_option->val > curr_option->value_min)
325        {
326            EventMenu_ChangeOptionVal(gobj, curr_option, curr_option->val - 1);
327            SFX_PlayCommon(2);
328        }
329    }
330    else if (inputs & (HSD_BUTTON_RIGHT | HSD_BUTTON_DPAD_RIGHT))
331    {
332        if ((curr_option->kind == OPTKIND_STRING || curr_option->kind == OPTKIND_INT)
333                && curr_option->val - curr_option->value_min < curr_option->value_num - 1)
334        {
335            EventMenu_ChangeOptionVal(gobj, curr_option, curr_option->val + 1);
336            SFX_PlayCommon(2);
337        }
338    }
339    else if (inputs & HSD_BUTTON_A)
340    {
341        if (curr_option->kind == OPTKIND_MENU)
342        {
343            EventMenu_NextMenu(gobj, curr_option->menu);
344            SFX_PlayCommon(1);
345        }
346        else if (curr_option->kind == OPTKIND_FUNC)
347        {
348            // execute function option
349            if (!curr_option->OnSelect)
350                assert("Missing menu function");
351            curr_option->OnSelect(gobj);
352
353            EventMenu_UpdateText(gobj);
354            SFX_PlayCommon(1);
355        }
356    }
357}
358
359void EventMenu_CreateModel(GOBJ *gobj)
360{
361    MenuData *menu_data = gobj->userdata;
362
363    // create options background
364    evMenu *menu_assets = event_vars->menu_assets;
365    JOBJ *jobj_options = JOBJ_LoadJoint(menu_assets->menu);
366    // Add to gobj
367    GObj_AddObject(gobj, 3, jobj_options);
368    GObj_DestroyGXLink(gobj);
369    GObj_AddGXLink(gobj, EventMenu_MenuGX, GXLINK_MENUMODEL, GXPRI_MENUMODEL);
370
371    // JOBJ array for getting the corner joints
372    JOBJ *corners[4];
373
374    // Create a rowbox for every option row. Rowboxes are the background behind
375    // the option value.
376    for (int i = 0; i < MENU_MAXOPTION; i++)
377    {
378        // create a border and attach to root jobj
379        JOBJ *jobj_rowbox = JOBJ_LoadJoint(menu_assets->popup);
380        JOBJ_AddChild(gobj->hsd_object, jobj_rowbox);
381        // Modify scale and position
382        JOBJ_GetChild(jobj_rowbox, corners, 2, 3, 4, 5, -1);
383        corners[0]->trans.X = -(ROWBOX_WIDTH / 2) + ROWBOX_X;
384        corners[0]->trans.Y = (ROWBOX_HEIGHT / 2) + ROWBOX_Y + (i * ROWBOX_YOFFSET);
385        corners[1]->trans.X = (ROWBOX_WIDTH / 2) + ROWBOX_X;
386        corners[1]->trans.Y = (ROWBOX_HEIGHT / 2) + ROWBOX_Y + (i * ROWBOX_YOFFSET);
387        corners[2]->trans.X = -(ROWBOX_WIDTH / 2) + ROWBOX_X;
388        corners[2]->trans.Y = -(ROWBOX_HEIGHT / 2) + ROWBOX_Y + (i * ROWBOX_YOFFSET);
389        corners[3]->trans.X = (ROWBOX_WIDTH / 2) + ROWBOX_X;
390        corners[3]->trans.Y = -(ROWBOX_HEIGHT / 2) + ROWBOX_Y + (i * ROWBOX_YOFFSET);
391        JOBJ_SetFlags(jobj_rowbox, JOBJ_HIDDEN);
392        DOBJ_SetFlags(jobj_rowbox->dobj, DOBJ_HIDDEN);
393        jobj_rowbox->dobj->next->mobj->mat->alpha = 0.6;
394        GXColor gx_color = ROWBOX_COLOR;
395        jobj_rowbox->dobj->next->mobj->mat->diffuse = gx_color;
396        // store pointer
397        menu_data->rowboxes[i] = jobj_rowbox;
398    }
399
400    // create a highlight jobj and attach to root jobj
401    JOBJ *jobj_highlight = JOBJ_LoadJoint(menu_assets->popup);
402    JOBJ_AddChild(gobj->hsd_object, jobj_highlight);
403    // remove outline
404    DOBJ_SetFlags(jobj_highlight->dobj, DOBJ_HIDDEN);
405    // move it into position
406    JOBJ_GetChild(jobj_highlight, corners, 2, 3, 4, 5, -1);
407    corners[0]->trans.X = -(MENUHIGHLIGHT_WIDTH / 2) + MENUHIGHLIGHT_X;
408    corners[0]->trans.Y = (MENUHIGHLIGHT_HEIGHT / 2) + MENUHIGHLIGHT_Y;
409    corners[1]->trans.X = (MENUHIGHLIGHT_WIDTH / 2) + MENUHIGHLIGHT_X;
410    corners[1]->trans.Y = (MENUHIGHLIGHT_HEIGHT / 2) + MENUHIGHLIGHT_Y;
411    corners[2]->trans.X = -(MENUHIGHLIGHT_WIDTH / 2) + MENUHIGHLIGHT_X;
412    corners[2]->trans.Y = -(MENUHIGHLIGHT_HEIGHT / 2) + MENUHIGHLIGHT_Y;
413    corners[3]->trans.X = (MENUHIGHLIGHT_WIDTH / 2) + MENUHIGHLIGHT_X;
414    corners[3]->trans.Y = -(MENUHIGHLIGHT_HEIGHT / 2) + MENUHIGHLIGHT_Y;
415    GXColor highlight = MENUHIGHLIGHT_COLOR;
416    jobj_highlight->dobj->next->mobj->mat->alpha = 0.4;
417    jobj_highlight->dobj->next->mobj->mat->diffuse = highlight;
418    menu_data->highlight_menu = jobj_highlight;
419
420    // create scroll bar and attach to root jobj
421    JOBJ *scroll_jobj = JOBJ_LoadJoint(menu_assets->scroll);
422    JOBJ_AddChild(gobj->hsd_object, scroll_jobj);
423    JOBJ_GetChild(scroll_jobj, corners, 2, 3, -1);
424    scroll_jobj->scale.X = MENUSCROLL_SCALE;
425    scroll_jobj->scale.Y = MENUSCROLL_SCALEY;
426    scroll_jobj->trans.X = MENUSCROLL_X;
427    scroll_jobj->trans.Y = MENUSCROLL_Y;
428    menu_data->scroll_top = corners[0];
429    menu_data->scroll_bot = corners[1];
430    GXColor scroll_color = MENUSCROLL_COLOR;
431    scroll_jobj->dobj->next->mobj->mat->alpha = 0.6;
432    scroll_jobj->dobj->next->mobj->mat->diffuse = scroll_color;
433    menu_data->scrollbar = scroll_jobj;
434}
435
436void EventMenu_CreateText(GOBJ *gobj)
437{
438    MenuData *menu_data = gobj->userdata;
439    Text *text;
440    int canvas_index = menu_data->canvas_menu;
441
442    if (menu_data->text_name || menu_data->text_value ||
443            menu_data->text_title || menu_data->text_desc)
444        assert("Menu text already created");
445
446    // Create Title
447    text = Text_CreateText(2, canvas_index);
448    text->gobj->gx_cb = EventMenu_TextGX;
449    menu_data->text_title = text;
450    text->kerning = 1;
451    text->use_aspect = 1;
452    text->aspect.X = MENU_TITLEASPECT;
453    text->viewport_scale.X = MENU_CANVASSCALE;
454    text->viewport_scale.Y = MENU_CANVASSCALE;
455
456    // output menu title
457    float x = MENU_TITLEXPOS;
458    float y = MENU_TITLEYPOS;
459    int subtext = Text_AddSubtext(text, x, y, "");
460    Text_SetScale(text, subtext, MENU_TITLESCALE, MENU_TITLESCALE);
461
462    // Create Description
463    text = Text_CreateText(2, canvas_index);
464    text->gobj->gx_cb = EventMenu_TextGX;
465    menu_data->text_desc = text;
466
467    text->trans.X = MENU_DESCXPOS;
468    text->trans.Y = MENU_DESCYPOS;
469    text->kerning = 1;
470    text->use_aspect = 1;
471    text->aspect.X = MENU_DESCTXTASPECT;
472    text->viewport_scale.X = MENU_CANVASSCALE;
473    text->viewport_scale.Y = MENU_CANVASSCALE;
474
475    for (int i = 0; i < MENU_DESCLINEMAX; i++)
476    {
477        float y = i * MENU_DESCYOFFSET;
478        Text_AddSubtext(text, 0, y, "");
479    }
480
481    // Create Names
482    text = Text_CreateText(2, canvas_index);
483    text->gobj->gx_cb = EventMenu_TextGX;
484    menu_data->text_name = text;
485    text->kerning = 1;
486    text->use_aspect = 1;
487    text->aspect.X = MENU_NAMEASPECT;
488    text->viewport_scale.X = MENU_CANVASSCALE;
489    text->viewport_scale.Y = MENU_CANVASSCALE;
490
491    for (int i = 0; i < MENU_MAXOPTION; i++)
492    {
493        float x = MENU_OPTIONNAMEXPOS;
494        float y = MENU_OPTIONNAMEYPOS + (i * MENU_TEXTYOFFSET);
495        Text_AddSubtext(text, x, y, "");
496    }
497
498    // Create Values
499    text = Text_CreateText(2, canvas_index);
500    text->gobj->gx_cb = EventMenu_TextGX;
501    menu_data->text_value = text;
502    text->align = 1;
503    text->kerning = 1;
504    text->use_aspect = 1;
505    text->aspect.X = MENU_VALASPECT;
506    text->viewport_scale.X = MENU_CANVASSCALE;
507    text->viewport_scale.Y = MENU_CANVASSCALE;
508
509    // Output all values
510    for (int i = 0; i < MENU_MAXOPTION; i++)
511    {
512        float x = MENU_OPTIONVALXPOS;
513        float y = MENU_OPTIONVALYPOS + (i * MENU_TEXTYOFFSET);
514        Text_AddSubtext(text, x, y, "");
515    }
516}
517
518void EventMenu_UpdateText(GOBJ *gobj)
519{
520    MenuData *menu_data = gobj->userdata;
521    EventMenu *menu = menu_data->curr_menu;
522    s32 cursor = menu->cursor;
523    s32 scroll = menu->scroll;
524    EventOption *curr_option = &menu->options[cursor + scroll];
525    Text *text;
526
527    // Update Title
528    text = menu_data->text_title;
529    Text_SetText(text, 0, menu->name);
530
531    // Update Description
532    text = menu_data->text_desc;
533    for (int i = 0; i < MENU_DESCLINEMAX; i++) {
534        char *line = curr_option->desc[i];
535        if (line)
536            Text_SetText(text, i, line);
537        else
538            Text_SetText(text, i, "");
539    }
540
541    for (int i = 0; i < min(menu->option_num, MENU_MAXOPTION); i++)
542    {
543        EventOption *option = &menu->options[scroll + i];
544
545        // Update option name
546        Text_SetText(menu_data->text_name, i, option->name);
547
548        // Update option value and rowbox
549        JOBJ* rowbox = menu_data->rowboxes[i];
550        JOBJ_ClearFlags(rowbox, JOBJ_HIDDEN);
551        GXColor rowbox_color = ROWBOX_COLOR;
552        rowbox->dobj->next->mobj->mat->diffuse = rowbox_color;
553
554        if (option->kind == OPTKIND_STRING) {
555            Text_SetText(menu_data->text_value, i, option->values[option->val]);
556        }
557        else if (option->kind == OPTKIND_INT) {
558            Text_SetText(menu_data->text_value, i, option->format, option->val);
559        }
560        else if (option->kind == OPTKIND_TOGGLE) {
561            if (option->val) {
562                Text_SetText(menu_data->text_value, i, "On");
563                GXColor color = ROWBOX_ONCOLOR;
564                rowbox->dobj->next->mobj->mat->diffuse = color;
565            }
566            else {
567                Text_SetText(menu_data->text_value, i, "Off");
568            }
569        }
570        else {
571            Text_SetText(menu_data->text_value, i, "");
572            JOBJ_SetFlags(rowbox, JOBJ_HIDDEN);
573        }
574
575        // Grey out text if the option is disabled
576        GXColor color = option->disable ?
577            (GXColor){ 128, 128, 128, 0 } :
578            (GXColor){ 255, 255, 255, 255 };
579        Text_SetColor(menu_data->text_name, i, &color);
580        Text_SetColor(menu_data->text_value, i, &color);
581    }
582
583    // Blank out lines past end of options
584    for (int i = menu->option_num; i < MENU_MAXOPTION; i++)
585    {
586        Text_SetText(menu_data->text_name, i, "");
587        Text_SetText(menu_data->text_value, i, "");
588        JOBJ_SetFlags(menu_data->rowboxes[i], JOBJ_HIDDEN);
589    }
590
591    // update cursor position
592    JOBJ *highlight_joint = menu_data->highlight_menu;
593    highlight_joint->trans.Y = cursor * MENUHIGHLIGHT_YOFFSET;
594
595    // update scrollbar position
596    if (menu->option_num > MENU_MAXOPTION) {
597        if (menu->scroll > menu->option_num - MENU_MAXOPTION)
598            assert("Invalid scroll position");
599        float len = ((float) MENU_MAXOPTION / menu->option_num) * MENUSCROLL_MAXLENGTH;
600        float space = MENUSCROLL_MAXLENGTH - len;
601        float top = space * menu->scroll / (menu->option_num - MENU_MAXOPTION);
602
603        // scroll bar grows/moves in the negative Y direction, hence the -
604        menu_data->scroll_top->trans.Y = -top;
605        menu_data->scroll_bot->trans.Y = -len;
606        JOBJ_ClearFlags(menu_data->scrollbar, JOBJ_HIDDEN);
607    }
608    else {
609        JOBJ_SetFlags(menu_data->scrollbar, JOBJ_HIDDEN);
610    }
611
612    JOBJ_SetMtxDirtySub(gobj->hsd_object);
613}