-#ifndef WORKSHOP_C
-#define WORKSHOP_C
-
-#include "workshop.h"
-
-#define VG_GAME
-#include "vg/vg.h"
+#include "vg/vg_engine.h"
#include "vg/vg_tex.h"
+#include "vg/vg_image.h"
#include "vg/vg_msg.h"
+#include "vg/vg_binstr.h"
+#include "vg/vg_loader.h"
+#include "vg/vg_io.h"
#include "ent_skateshop.h"
#include "vg/vg_steam_auth.h"
#include "vg/vg_steam_ugc.h"
#include "vg/vg_steam_friends.h"
#include "steam.h"
-#include "highscores.h"
+#include "workshop.h"
-static struct ui_dropdown_opt workshop_form_visibility_opts[] = {
- { "Public", k_ERemoteStoragePublishedFileVisibilityPublic },
- { "Unlisted", k_ERemoteStoragePublishedFileVisibilityUnlisted },
- { "Friends Only", k_ERemoteStoragePublishedFileVisibilityFriendsOnly },
- { "Private", k_ERemoteStoragePublishedFileVisibilityPrivate },
+struct workshop_form workshop_form;
+
+static struct ui_enum_opt workshop_form_visibility_opts[] = {
+ { k_ERemoteStoragePublishedFileVisibilityPublic, "Public" },
+ { k_ERemoteStoragePublishedFileVisibilityUnlisted, "Unlisted" },
+ { k_ERemoteStoragePublishedFileVisibilityFriendsOnly, "Friends Only" },
+ { k_ERemoteStoragePublishedFileVisibilityPrivate, "Private" },
};
-static struct ui_dropdown_opt workshop_form_type_opts[] = {
- { "None", k_addon_type_none },
- { "Board", k_addon_type_board },
- { "World", k_addon_type_world },
- { "Player", k_addon_type_player },
+static struct ui_enum_opt workshop_form_type_opts[] = {
+ { k_addon_type_none, "None" },
+ { k_addon_type_board, "Board" },
+ { k_addon_type_world, "World" },
+ { k_addon_type_player, "Player" },
};
/*
* Close the form and discard UGC query result
*/
-VG_STATIC void workshop_quit_form(void){
+static void workshop_quit_form(void){
player_board_unload( &workshop_form.board_model );
workshop_form.file_intent = k_workshop_form_file_intent_none;
/*
* Delete all information about the submission
*/
-VG_STATIC void workshop_reset_submission_data(void)
+static void workshop_reset_submission_data(void)
{
workshop_form.submission.file_id = 0; /* assuming id of 0 is none/invalid */
workshop_form.submission.description[0] = '\0';
workshop_form.submission.title[0] = '\0';
workshop_form.submission.author[0] = '\0';
- workshop_form.submission.submission_type_selection.value =
+ workshop_form.submission.submission_type_selection =
k_addon_type_none;
- workshop_form.submission.submission_type_selection.index = 0;
workshop_form.submission.type = k_addon_type_none;
- workshop_form.submission.visibility.value =
+ workshop_form.submission.visibility =
k_ERemoteStoragePublishedFileVisibilityPublic;
- workshop_form.submission.visibility.index = 0;
workshop_form.addon_folder[0] = '\0';
player_board_unload( &workshop_form.board_model );
/*
* Mostly copies of what it sais on the Steam API documentation
*/
-VG_STATIC const char *workshop_EResult_user_string( EResult result )
+static const char *workshop_EResult_user_string( EResult result )
{
switch( result ){
case k_EResultInsufficientPrivilege:
/*
* The endpoint of this operation
*/
-VG_STATIC void on_workshop_update_result( void *data, void *user )
+static void on_workshop_update_result( void *data, void *user )
{
vg_info( "Recieved workshop update result\n" );
SubmitItemUpdateResult_t *result = data;
workshop_form.op = k_workshop_op_none;
}
-VG_STATIC const char *workshop_filetype_folder(void){
+static const char *workshop_filetype_folder(void){
enum addon_type type = workshop_form.submission.type;
if ( type == k_addon_type_board ) return "boards/";
else if( type == k_addon_type_player ) return "playermodels/";
- else if( type == k_addon_type_world ) return "worlds/";
+ else if( type == k_addon_type_world ) return "maps/";
return "unknown_addon_type/";
}
* reciever on completion of packaging the files, it will then start the item
* update with Steam API
*/
-VG_STATIC void workshop_form_upload_submission( PublishedFileId_t file_id,
+static void workshop_form_upload_submission( PublishedFileId_t file_id,
char *metadata )
{
ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
vg_info( "Setting visibility\n" );
SteamAPI_ISteamUGC_SetItemVisibility( hSteamUGC, handle,
- workshop_form.submission.visibility.value );
+ workshop_form.submission.visibility );
vg_info( "Submitting updates\n" );
vg_steam_async_call *call = vg_alloc_async_steam_api_call();
* Steam API call result for when we've created a new item on their network, or
* not, if it has failed
*/
-VG_STATIC void on_workshop_createitem( void *data, void *user )
+static void on_workshop_createitem( void *data, void *user )
{
CreateItemResult_t *result = data;
/*
* Starts the workshop upload process through Steam API
*/
-VG_STATIC void workshop_form_async_submit_begin( void *payload, u32 size )
+static void workshop_form_async_submit_begin( void *payload, u32 size )
{
/* use existing file */
/*
* Downloads the framebuffer into scratch memory
*/
-VG_STATIC void workshop_form_async_download_image( void *payload, u32 size )
+static void workshop_form_async_download_image( void *payload, u32 size )
{
int w, h;
- render_fb_get_current_res( gpipeline.fb_workshop_preview, &w, &h );
+ vg_framebuffer_get_res( g_render.fb_workshop_preview, &w, &h );
vg_linear_clear( vg_mem.scratch );
workshop_form.img_buffer = vg_linear_alloc( vg_mem.scratch, w*h*3 );
vg_info( "read framebuffer: glReadPixels( %dx%d )\n", w,h );
- glBindFramebuffer( GL_READ_FRAMEBUFFER, gpipeline.fb_workshop_preview->fb );
+ glBindFramebuffer( GL_READ_FRAMEBUFFER, g_render.fb_workshop_preview->id );
glReadBuffer( GL_COLOR_ATTACHMENT0 );
glReadPixels( 0,0, w,h, GL_RGB, GL_UNSIGNED_BYTE, workshop_form.img_buffer );
/*
* Thread which kicks off the upload process
*/
-VG_STATIC void _workshop_form_submit_thread( void *data )
+static void _workshop_form_submit_thread( void *data )
{
vg_async_call( workshop_form_async_download_image, NULL, 0 );
vg_async_stall();
* Create the metadata file
* -----------------------------------------------------------------------*/
u8 descriptor_buf[ 512 ];
- vg_msg descriptor = {0};
- descriptor.buf = descriptor_buf;
- descriptor.max = sizeof(descriptor_buf);
-
+ vg_msg descriptor;
+ vg_msg_init( &descriptor, descriptor_buf, sizeof(descriptor_buf) );
vg_linear_clear( vg_mem.scratch );
/* short description */
vg_msg_frame( &descriptor, "workshop" );
vg_msg_wkvstr( &descriptor, "title", workshop_form.submission.title );
//vg_msg_wkvstr( &descriptor, "author", "unknown" );
- vg_msg_wkvu32( &descriptor, "type", workshop_form.submission.type );
+ vg_msg_wkvnum( &descriptor, "type", k_vg_msg_u32, 1,
+ &workshop_form.submission.type );
vg_msg_wkvstr( &descriptor, "folder", workshop_form.addon_folder );
vg_msg_end_frame( &descriptor );
//vg_msg_wkvstr( &descriptor, "location", "USA" );
- char *short_descriptor_str = vg_linear_alloc( vg_mem.scratch,
- vg_align8(descriptor.cur*2+1));
- vg_bin_str( descriptor_buf, short_descriptor_str, descriptor.cur );
- short_descriptor_str[descriptor.cur*2] = '\0';
+ char *short_descriptor_str =
+ vg_linear_alloc( vg_mem.scratch, vg_align8(descriptor.cur.co*2+1));
+ vg_bin_str( descriptor_buf, short_descriptor_str, descriptor.cur.co );
+ short_descriptor_str[descriptor.cur.co*2] = '\0';
vg_info( "binstr: %s\n", short_descriptor_str );
vg_dir dir;
- if( !vg_dir_open( &dir, folder.buffer ) ){
+ if( !vg_dir_open( &dir, folder.buffer ) )
+ {
vg_error( "could not open addon folder '%s'\n", folder.buffer );
workshop_form.op = k_workshop_op_none;
return;
}
- while( vg_dir_next_entry(&dir) ){
- if( vg_dir_entry_type(&dir) == k_vg_entry_type_file ){
+ while( vg_dir_next_entry(&dir) )
+ {
+ if( vg_dir_entry_type(&dir) == k_vg_entry_type_file )
+ {
const char *d_name = vg_dir_entry_name(&dir);
if( d_name[0] == '.' ) continue;
workshop_form.op = k_workshop_op_none;
return;
}
- fwrite( descriptor_buf, descriptor.cur, 1, fp );
+ fwrite( descriptor_buf, descriptor.cur.co, 1, fp );
fclose( fp );
/* Save the preview
/*
* Entry point for the publishing submission operation
*/
-VG_STATIC void workshop_op_submit(void){
+static void workshop_op_submit( ui_context *ctx )
+{
/* TODO: Show these errors to the user */
- if( workshop_form.submission.submit_title ){
- if( !workshop_form.submission.title[0] ){
- ui_start_modal( "Cannot submit because a title is required\n",
- UI_MODAL_WARN);
+ if( workshop_form.submission.submit_title )
+ {
+ if( !workshop_form.submission.title[0] )
+ {
+ ui_start_modal( ctx, "Cannot submit because a title is required\n",
+ UI_MODAL_WARN );
workshop_form.op = k_workshop_op_none;
return;
}
}
- if( workshop_form.submission.submit_description ){
- if( !workshop_form.submission.description[0] ){
- ui_start_modal( "Cannot submit because a description is required\n",
+ if( workshop_form.submission.submit_description )
+ {
+ if( !workshop_form.submission.description[0] )
+ {
+ ui_start_modal( ctx,
+ "Cannot submit because a description is required\n",
UI_MODAL_WARN );
workshop_form.op = k_workshop_op_none;
return;
}
}
- if( workshop_form.submission.submit_file_and_image ){
- if( workshop_form.file_intent == k_workshop_form_file_intent_none ){
- ui_start_modal( "Cannot submit because the file is "
+ if( workshop_form.submission.submit_file_and_image )
+ {
+ if( workshop_form.file_intent == k_workshop_form_file_intent_none )
+ {
+ ui_start_modal( ctx, "Cannot submit because the file is "
"empty or unspecified\n", UI_MODAL_WARN );
workshop_form.op = k_workshop_op_none;
return;
/*
* Reciever for completion of the model file load
*/
-VG_STATIC void workshop_form_loadmodel_async_complete( void *payload, u32 size )
+static void workshop_form_loadmodel_async_complete( void *payload, u32 size )
{
v2_zero( workshop_form.view_angles );
v3_zero( workshop_form.view_offset );
/*
* Reciever for failure to load
*/
-VG_STATIC void workshop_form_loadmodel_async_error( void *payload, u32 size ){
+static void workshop_form_loadmodel_async_error( void *payload, u32 size ){
}
/*
* Thread which loads the model from the disk
*/
-VG_STATIC void _workshop_form_load_thread( void *data )
+static void _workshop_form_load_thread( void *data )
{
char path_buf[4096];
vg_str folder;
/*
* Entry point for load model operation
*/
-VG_STATIC void workshop_op_load_model(void){
+static void workshop_op_load_model( ui_context *ctx )
+{
world_instance *world = world_current_instance();
workshop_form.view_world = world;
- if( workshop_form.submission.type == k_addon_type_board ){
- if( mdl_arrcount( &world->ent_swspreview ) ){
- workshop_form.ptr_ent =
- mdl_arritm( &world->ent_swspreview, 0 );
+ if( workshop_form.submission.type == k_addon_type_board )
+ {
+ if( mdl_arrcount( &world->ent_swspreview ) )
+ {
+ workshop_form.ptr_ent = mdl_arritm( &world->ent_swspreview, 0 );
}
- else{
- ui_start_modal( "There is no ent_swspreview in the level. \n"
+ else
+ {
+ ui_start_modal( ctx, "There is no ent_swspreview in the level. \n"
"Cannot publish here\n", UI_MODAL_BAD );
workshop_form.op = k_workshop_op_none;
return;
}
}
else if( workshop_form.submission.type == k_addon_type_player ){}
- else {
- ui_start_modal( "Don't know how to prepare for this item type. \n"
+ else
+ {
+ ui_start_modal( ctx, "Don't know how to prepare for this item type. \n"
"Please contact the developers.\n", UI_MODAL_BAD );
workshop_form.op = k_workshop_op_none;
return;
/*
* The image has been decoded and is ready to slap into the framebuffer
*/
-VG_STATIC void workshop_form_async_imageload( void *data, u32 len )
+static void workshop_form_async_imageload( void *data, u32 len )
{
- if( data ){
- struct framebuffer_attachment *a =
- &gpipeline.fb_workshop_preview->attachments[0];
+ if( data )
+ {
+ vg_framebuffer_attachment *a =
+ &g_render.fb_workshop_preview->attachments[0];
glBindTexture( GL_TEXTURE_2D, a->id );
glTexSubImage2D( GL_TEXTURE_2D, 0,0,0,
stbi_image_free( data );
vg_success( "Loaded workshop preview image\n" );
}
- else{
+ else
+ {
snprintf( workshop_form.error_msg, sizeof(workshop_form.error_msg),
"Preview image could not be loaded. Reason: %s\n",
stbi_failure_reason() );
- ui_start_modal( workshop_form.error_msg, UI_MODAL_BAD );
+ ui_start_modal( &vg_ui.ctx, workshop_form.error_msg, UI_MODAL_BAD );
}
workshop_form.op = k_workshop_op_none;
}
/*
* Load the image located at ./workshop_preview.jpg into our framebuffer
*/
-VG_STATIC void _workshop_load_preview_thread( void *data ){
+static void _workshop_load_preview_thread( void *data ){
char path_buf[ 4096 ];
vg_str path;
vg_strnull( &path, path_buf, 4096 );
vg_strcat( &path, workshop_form.addon_folder );
vg_strcat( &path, "/preview.jpg" );
- if( vg_strgood( &path ) ){
+ if( vg_strgood( &path ) )
+ {
stbi_set_flip_vertically_on_load(1);
int x, y, nc;
u8 *rgb = stbi_load( path.buffer, &x, &y, &nc, 3 );
- if( rgb ){
- if( (x == WORKSHOP_PREVIEW_WIDTH) && (y == WORKSHOP_PREVIEW_HEIGHT) ){
+ if( rgb )
+ {
+ if( (x == WORKSHOP_PREVIEW_WIDTH) && (y == WORKSHOP_PREVIEW_HEIGHT) )
+ {
vg_async_call( workshop_form_async_imageload, rgb, x*y*3 );
}
- else{
+ else
+ {
vg_error( "Resolution does not match framebuffer, so we can't"
" show it\n" );
stbi_image_free( rgb );
vg_async_call( workshop_form_async_imageload, NULL, 0 );
}
}
- else{
+ else
+ {
vg_async_call( workshop_form_async_imageload, NULL, 0 );
}
}
- else{
+ else
+ {
vg_async_call( workshop_form_async_imageload, NULL, 0 );
}
}
/*
* Entry point to view operation
*/
-VG_STATIC void workshop_op_download_and_view_submission( int result_index )
+static void workshop_op_download_and_view_submission( int result_index )
{
workshop_form.op = k_workshop_op_downloading_submission;
ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
workshop_form.submission.file_id = details.m_nPublishedFileId;
workshop_form.file_intent = k_workshop_form_file_intent_keep_old;
workshop_form.page = k_workshop_form_edit;
- workshop_form.submission.visibility.value = details.m_eVisibility;
+ workshop_form.submission.visibility = details.m_eVisibility;
workshop_form.submission.type = k_addon_type_none;
- workshop_form.submission.submission_type_selection.index = 0;
- workshop_form.submission.submission_type_selection.value =
- k_addon_type_none;
+ workshop_form.submission.submission_type_selection = k_addon_type_none;
- if( have_meta ){
+ if( have_meta )
+ {
u32 len = strlen(metadata_str);
vg_info( "Metadata: %s\n", metadata_str );
vg_str_bin( metadata_str, metadata_buf, len );
- vg_msg root = {0};
- root.buf = metadata_buf;
- root.len = len/2;
- root.max = len/2;
+ vg_msg msg;
+ vg_msg_init( &msg, metadata_buf, len/2 );
- vg_msg workshop = root;
- if( vg_msg_seekframe( &workshop, "workshop", k_vg_msg_first )){
- u32 type = vg_msg_seekkvu32( &workshop, "type", k_vg_msg_first );
+ if( vg_msg_seekframe( &msg, "workshop" ))
+ {
+ u32 type;
+ vg_msg_getkvintg( &msg, "type", k_vg_msg_u32, &type, NULL );
workshop_form.submission.type = type;
- workshop_form.submission.submission_type_selection.value = type;
+ workshop_form.submission.submission_type_selection = type;
- const char *kv_folder = vg_msg_seekkvstr( &workshop, "folder",
- k_vg_msg_first );
- if( kv_folder ){
+ const char *kv_folder = vg_msg_getkvstr( &msg, "folder" );
+ if( kv_folder )
+ {
vg_strncpy( kv_folder, workshop_form.addon_folder,
sizeof(workshop_form.addon_folder),
k_strncpy_always_add_null );
}
}
}
- else{
+ else
+ {
vg_error( "No metadata was returned with this item.\n" );
}
- /* TODO.... */
- for( i32 i=0; i<vg_list_size(workshop_form_visibility_opts); i++ ){
- if( workshop_form_visibility_opts[i].value == details.m_eVisibility ){
- workshop_form.submission.visibility.index = i;
- break;
- }
- }
- for( i32 i=0; i<vg_list_size(workshop_form_type_opts); i++ ){
- if( workshop_form_type_opts[i].value ==
- workshop_form.submission.submission_type_selection.value ){
- workshop_form.submission.submission_type_selection.index = i;
- break;
- }
- }
-
- render_fb_bind( gpipeline.fb_workshop_preview, 0 );
+ vg_framebuffer_bind( g_render.fb_workshop_preview, 1.0f );
glClearColor( 0.2f, 0.0f, 0.0f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
vg_loader_start( _workshop_load_preview_thread, NULL );
}
- else{
+ else
+ {
vg_error( "GetQueryUGCResult: Index out of range\n" );
workshop_form.op = k_workshop_op_none;
}
/*
* View a page of results on the sidebar
*/
-VG_STATIC void workshop_view_page( int req )
+static void workshop_view_page( int req )
{
- if( workshop_form.ugc_query.result != k_EResultOK ){
+ if( workshop_form.ugc_query.result != k_EResultOK )
+ {
vg_error( "Tried to change page without complete data\n" );
workshop_form.op = k_workshop_op_none;
return;
workshop_form.published_files_list_length = count;
ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
- for( int i=0; i<count; i ++ ){
+ for( int i=0; i<count; i ++ )
+ {
struct published_file *pfile = &workshop_form.published_files_list[i];
SteamUGCDetails_t details;
start+i,
&details ) )
{
- if( details.m_eResult != k_EResultOK ){
+ if( details.m_eResult != k_EResultOK )
+ {
snprintf( pfile->title, 80, "Error (%d)", details.m_eResult );
}
- else{
+ else
+ {
vg_strncpy( details.m_rgchTitle, pfile->title, 80,
k_strncpy_always_add_null );
}
pfile->result = details.m_eResult;
pfile->result_index = start+i;
}
- else{
+ else
+ {
pfile->result = k_EResultValueOutOfRange;
pfile->result_index = -1;
snprintf( pfile->title, 80, "Error (invalid index)" );
/*
* Steam API result for when we recieve submitted UGC information about the user
*/
-VG_STATIC void on_workshop_UGCQueryComplete( void *data, void *userdata )
+static void on_workshop_UGCQueryComplete( void *data, void *userdata )
{
SteamUGCQueryCompleted_t *query = data;
workshop_form.ugc_query.result = query->m_eResult;
- if( query->m_eResult == k_EResultOK ){
- if( query->m_unTotalMatchingResults > 50 ){
+ if( query->m_eResult == k_EResultOK )
+ {
+ if( query->m_unTotalMatchingResults > 50 )
+ {
vg_warn( "You have %d items submitted, "
"we can only view the last 50\n" );
}
workshop_view_page( 0 );
}
- else{
+ else
+ {
vg_error( "Steam UGCQuery failed (%d)\n", query->m_eResult );
workshop_form.view_published_page_count = 0;
workshop_form.view_published_page_id = 0;
/*
* Console command to open the workshop publisher
*/
-VG_STATIC int workshop_submit_command( int argc, const char *argv[] )
+int workshop_submit_command( int argc, const char *argv[] )
{
- if( !steam_ready ){
- ui_start_modal( "Steam API is not initialized\n", UI_MODAL_BAD );
+ if( !steam_ready )
+ {
+ ui_start_modal( &vg_ui.ctx,
+ "Steam API is not initialized\n", UI_MODAL_BAD );
return 0;
}
return 0;
}
-VG_STATIC void workshop_init(void)
+void workshop_init(void)
{
vg_console_reg_cmd( "workshop_submit", workshop_submit_command, NULL );
}
-VG_STATIC void workshop_render_world_preview(void){
- render_fb_bind( gpipeline.fb_workshop_preview, 0 );
+static void workshop_render_world_preview(void)
+{
+ vg_framebuffer_bind( g_render.fb_workshop_preview, 1.0f );
glClearColor( 0.0f, 0.0f, 0.3f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
- render_world( localplayer.viewable_world, &skaterift.cam, 1 );
+ render_world( world_current_instance(), &g_render.cam, 0, 0, 1, 1 );
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
glViewport( 0,0, vg.window_x, vg.window_y );
/*
* Redraw the playermodel into the workshop framebuffer
*/
-VG_STATIC void workshop_render_player_preview(void){
- render_fb_bind( gpipeline.fb_workshop_preview, 0 );
+static void workshop_render_player_preview(void)
+{
+ vg_framebuffer_bind( g_render.fb_workshop_preview, 1.0f );
glClearColor( 0.16f, 0.15f, 0.15f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
- struct skeleton *sk = &localplayer.playeravatar->sk;
+ struct skeleton *sk = &localplayer.skeleton;
player_pose res;
res.type = k_player_pose_type_ik;
v3_copy( res.root_co, transform[3] );
/* TODO: Function. */
- skeleton_apply_pose( sk, res.keyframes, k_anim_apply_defer_ik );
- skeleton_apply_ik_pass( sk );
- skeleton_apply_pose( sk, res.keyframes, k_anim_apply_deffered_only );
- skeleton_apply_inverses( sk );
- skeleton_apply_transform( sk, transform );
-
- camera cam;
+ skeleton_apply_pose( sk, res.keyframes, k_anim_apply_defer_ik,
+ localplayer.final_mtx );
+ skeleton_apply_ik_pass( sk, localplayer.final_mtx );
+ skeleton_apply_pose( sk, res.keyframes, k_anim_apply_deffered_only,
+ localplayer.final_mtx );
+ skeleton_apply_inverses( sk, localplayer.final_mtx );
+ skeleton_apply_transform( sk, transform, localplayer.final_mtx );
+
+ vg_camera cam;
v3_copy( (v3f){ 0.0f, 201.7f, 1.2f }, cam.pos );
cam.nearz = 0.01f;
cam.fov = 57.0f;
v3_zero( cam.angles );
- camera_update_transform( &cam );
- camera_update_view( &cam );
- camera_update_projection( &cam );
- camera_finalize( &cam );
+ vg_camera_update_transform( &cam );
+ vg_camera_update_view( &cam );
+ vg_camera_update_projection( &cam );
+ vg_camera_finalize( &cam );
- world_instance *world = localplayer.viewable_world;
- render_playermodel( &cam, world, 0, &workshop_form.player_model, sk );
+ render_playermodel( &cam, world_current_instance(), 0,
+ &workshop_form.player_model, sk, localplayer.final_mtx );
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
glViewport( 0,0, vg.window_x, vg.window_y );
/*
* Redraw the model file into the workshop framebuffer
*/
-VG_STATIC void workshop_render_board_preview(void){
- if( !workshop_form.ptr_ent ){
+static void workshop_render_board_preview(void)
+{
+ if( !workshop_form.ptr_ent )
+ {
return;
}
- render_fb_bind( gpipeline.fb_workshop_preview, 0 );
+ vg_framebuffer_bind( g_render.fb_workshop_preview, 1.0f );
glClearColor( 0.0f, 0.0f, 0.3f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
v3_add( display->transform.co, display1->transform.co, baseco );
v3_muls( baseco, 0.5f, baseco );
- camera cam;
+ vg_camera cam;
v3f basevector;
v3_sub( display->transform.co, ref->transform.co, basevector );
float dist = v3_length( basevector );
v3f baseangles;
- player_vector_angles( baseangles, basevector, 1.0f, 0.0f );
+ v3_angles( basevector, baseangles );
v2_add( workshop_form.view_angles, baseangles, cam.angles );
cam.angles[2] = 0.0f;
cam.farz = 100.0f;
cam.fov = ref->fov;
- camera_update_transform( &cam );
- camera_update_view( &cam );
- camera_update_projection( &cam );
- camera_finalize( &cam );
+ vg_camera_update_transform( &cam );
+ vg_camera_update_view( &cam );
+ vg_camera_update_projection( &cam );
+ vg_camera_finalize( &cam );
m4x3f mmdl, mmdl1;
mdl_transform_m4x3( &display->transform, mmdl );
glBufferSubData( GL_UNIFORM_BUFFER, 0,
sizeof(struct ub_world_lighting), &world->ub_lighting );
- render_world( world, &cam, 1 );
+ render_world( world, &cam, 0, 0, 0, 0 );
struct player_board_pose pose = {0};
render_board( &cam, world, board, mmdl, &pose, k_board_shader_entity );
render_board( &cam, world, board, mmdl1, &pose, k_board_shader_entity );
* -----------------------------------------------------------------------------
*/
-VG_STATIC void workshop_changed_model_path( char *buf, u32 len ){
+static void workshop_changed_model_path( ui_context *ctx, char *buf, u32 len )
+{
workshop_form.submission.submit_file_and_image = 1;
}
-VG_STATIC void workshop_changed_title( char *buf, u32 len ){
+static void workshop_changed_title( ui_context *ctx, char *buf, u32 len )
+{
workshop_form.submission.submit_title = 1;
}
-VG_STATIC void workshop_changed_description( char *buf, u32 len ){
+static void workshop_changed_description( ui_context *ctx, char *buf, u32 len )
+{
workshop_form.submission.submit_description = 1;
}
-VG_STATIC void workshop_form_gui_page_undecided( ui_rect content ){
+static void workshop_form_gui_page_undecided( ui_context *ctx, ui_rect content )
+{
ui_rect box;
rect_copy( content, box );
box[3] = 128;
ui_rect row;
ui_split( box, k_ui_axis_h, 28, 0, row, box );
- ui_text( row, "Select the type of item\n", 1, k_ui_align_middle_center,0);
+ ui_text( ctx, row,
+ "Select the type of item\n", 1, k_ui_align_middle_center,0);
ui_split( box, k_ui_axis_h, 28, 0, row, box );
- ui_enum( row, "Type:", workshop_form_type_opts,
+ ui_enum( ctx, row, "Type:", workshop_form_type_opts,
4, &workshop_form.submission.submission_type_selection );
ui_split( box, k_ui_axis_h, 8, 0, row, box );
ui_split( box, k_ui_axis_h, 28, 0, row, box );
ui_rect_center( row, button_l );
ui_split_ratio( button_l, k_ui_axis_v, 0.5f, 2, button_l, button_r );
- if( workshop_form.submission.submission_type_selection.value !=
- k_addon_type_none ){
- if( ui_button_text( button_l, "OK", 1 ) ){
- enum addon_type type =
- workshop_form.submission.submission_type_selection.value;
+ enum addon_type type = workshop_form.submission.submission_type_selection;
+ if( type != k_addon_type_none)
+ {
+ if( ui_button_text( ctx, button_l, "OK", 1 ) == 1 )
+ {
workshop_form.submission.type = type;
if( type == k_addon_type_world ){
}
}
}
- else{
- ui_fill( button_l, ui_colour(k_ui_bg) );
- ui_text( button_l, "OK", 1, k_ui_align_middle_center,
- ui_colour(k_ui_bg+4) );
+ else
+ {
+ ui_fill( ctx, button_l, ui_colour(ctx,k_ui_bg) );
+ ui_text( ctx, button_l, "OK", 1, k_ui_align_middle_center,
+ ui_colour(ctx, k_ui_bg+4) );
}
- if( ui_button_text( button_r, "Cancel", 1 ) ){
+ if( ui_button_text( ctx, button_r, "Cancel", 1 ) == 1 )
+ {
workshop_form.page = k_workshop_form_open;
workshop_form.file_intent = k_workshop_form_file_intent_none;
}
}
-VG_STATIC void workshop_form_gui_draw_preview( ui_rect img_box ){
+static void workshop_form_gui_draw_preview( ui_context *ctx, ui_rect img_box )
+{
enum addon_type type = workshop_form.submission.type;
- if( workshop_form.file_intent == k_workshop_form_file_intent_keep_old ){
- ui_image( img_box, gpipeline.fb_workshop_preview->attachments[0].id );
+ if( workshop_form.file_intent == k_workshop_form_file_intent_keep_old )
+ {
+ ui_image( ctx,
+ img_box, &g_render.fb_workshop_preview->attachments[0].id );
}
- else if( workshop_form.file_intent == k_workshop_form_file_intent_new ){
- ui_image( img_box, gpipeline.fb_workshop_preview->attachments[0].id );
+ else if( workshop_form.file_intent == k_workshop_form_file_intent_new )
+ {
+ ui_image( ctx,
+ img_box, &g_render.fb_workshop_preview->attachments[0].id );
- if( type == k_addon_type_world ){
+ if( type == k_addon_type_world )
+ {
return;
}
- int hover = ui_inside_rect( img_box, vg_ui.mouse ),
- target = ui_inside_rect( img_box, vg_ui.mouse_click );
+ int hover = ui_inside_rect( img_box, ctx->mouse ),
+ target = ui_inside_rect( img_box, ctx->mouse_click );
- if( ui_click_down(UI_MOUSE_MIDDLE) && target ){
+ if( ui_click_down(ctx,UI_MOUSE_MIDDLE) && target )
+ {
v3_copy( workshop_form.view_offset,
workshop_form.view_offset_begin );
}
- else if( ui_click_down(UI_MOUSE_LEFT) && target ){
+ else if( ui_click_down(ctx,UI_MOUSE_LEFT) && target )
+ {
v2_copy( workshop_form.view_angles,
workshop_form.view_angles_begin );
}
- if( ui_clicking(UI_MOUSE_MIDDLE) && target ){
- v2f delta = { vg_ui.mouse[0]-vg_ui.mouse_click[0],
- vg_ui.mouse[1]-vg_ui.mouse_click[1] };
+ if( ui_clicking(ctx,UI_MOUSE_MIDDLE) && target )
+ {
+ v2f delta = { ctx->mouse[0]-ctx->mouse_click[0],
+ ctx->mouse[1]-ctx->mouse_click[1] };
float *begin = workshop_form.view_offset_begin,
*offset = workshop_form.view_offset;
offset[2] = vg_clampf( begin[2]-delta[1]*0.002f, -1.0f, 1.0f );
workshop_form.view_changed = 1;
}
- else if( ui_clicking(UI_MOUSE_LEFT) && target ){
- v2f delta = { vg_ui.mouse[0]-vg_ui.mouse_click[0],
- vg_ui.mouse[1]-vg_ui.mouse_click[1] };
+ else if( ui_clicking(ctx,UI_MOUSE_LEFT) && target )
+ {
+ v2f delta = { ctx->mouse[0]-ctx->mouse_click[0],
+ ctx->mouse[1]-ctx->mouse_click[1] };
v2f angles;
v2_muladds( workshop_form.view_angles_begin, delta, 0.002f, angles);
workshop_form.view_changed = 1;
}
- if( !ui_clicking(UI_MOUSE_LEFT) && hover ){
+ if( !ui_clicking(ctx,UI_MOUSE_LEFT) && hover )
+ {
float zoom = workshop_form.view_dist;
zoom += vg.mouse_wheel[1] * -0.07f;
zoom = vg_clampf( zoom, 0.4f, 2.0f );
- if( zoom != workshop_form.view_dist ){
+ if( zoom != workshop_form.view_dist )
+ {
workshop_form.view_changed = 1;
workshop_form.view_dist = zoom;
}
}
}
- else{
- ui_text( img_box, "No image", 1, k_ui_align_middle_center,
- ui_colour( k_ui_orange ) );
+ else
+ {
+ ui_text( ctx, img_box, "No image", 1, k_ui_align_middle_center,
+ ui_colour( ctx, k_ui_orange ) );
}
}
-VG_STATIC void workshop_form_gui_edit_page( ui_rect content ){
+static void workshop_form_gui_edit_page( ui_context *ctx, ui_rect content )
+{
enum addon_type type = workshop_form.submission.type;
- if( type == k_addon_type_none ){
- workshop_form_gui_page_undecided( content );
+ if( type == k_addon_type_none )
+ {
+ workshop_form_gui_page_undecided( ctx, content );
return;
}
ui_rect image_plane;
ui_split( content, k_ui_axis_h, 300, 0, image_plane, content );
- ui_fill( image_plane, ui_colour( k_ui_bg+0 ) );
+ ui_fill( ctx, image_plane, ui_colour( ctx, k_ui_bg+0 ) );
ui_rect img_box;
ui_fit_item( image_plane, (ui_px[2]){ 3, 2 }, img_box );
- workshop_form_gui_draw_preview( img_box );
+ workshop_form_gui_draw_preview( ctx, img_box );
/* file path */
- ui_rect null, file_entry, file_button, file_label;
- ui_split( content, k_ui_axis_h, 8, 0, null, content );
- ui_split( content, k_ui_axis_h, 28, 0, file_entry, content );
+ ui_rect file_button, file_label;
char buf[128];
- snprintf( buf, 128, "Addon folder: skaterift/%s",
- workshop_filetype_folder() );
-
- ui_label( file_entry, buf, 1, 8, file_entry );
+ snprintf( buf, 128,
+ "Addon folder: skaterift/%s", workshop_filetype_folder() );
- if( type == k_addon_type_world ){
- struct ui_textbox_callbacks callbacks = {
+ if( type == k_addon_type_world )
+ {
+ struct ui_textbox_callbacks callbacks =
+ {
.change = workshop_changed_model_path
};
- ui_textbox( file_entry, workshop_form.addon_folder,
- vg_list_size(workshop_form.addon_folder), 0, &callbacks );
+ ui_textbox( ctx, content, buf, workshop_form.addon_folder,
+ vg_list_size(workshop_form.addon_folder), 1, 0, &callbacks );
}
- else{
+ else
+ {
+ ui_rect file_entry;
+ ui_standard_widget( ctx, content, file_entry, 1 );
ui_split( file_entry, k_ui_axis_v, -128, 0, file_entry, file_button );
- if( workshop_form.file_intent != k_workshop_form_file_intent_none ){
- ui_text( file_entry, workshop_form.addon_folder, 1,
- k_ui_align_middle_left, ui_colour( k_ui_fg+4 ) );
- if( ui_button_text( file_button, "Remove", 1 ) ){
+ if( workshop_form.file_intent != k_workshop_form_file_intent_none )
+ {
+ ui_text( ctx, file_entry, workshop_form.addon_folder, 1,
+ k_ui_align_middle_left, ui_colour( ctx, k_ui_fg+4 ) );
+
+ if( ui_button_text( ctx, file_button, "Remove", 1 ) == 1 )
+ {
if( type == k_addon_type_board )
player_board_unload( &workshop_form.board_model );
else if( type == k_addon_type_player )
workshop_form.addon_folder[0] = '\0';
}
}
- else{
- struct ui_textbox_callbacks callbacks = {
+ else
+ {
+ struct ui_textbox_callbacks callbacks =
+ {
.change = workshop_changed_model_path
};
- ui_textbox( file_entry, workshop_form.addon_folder,
- vg_list_size(workshop_form.addon_folder), 0, &callbacks );
+ ui_textbox( ctx, file_entry, buf, workshop_form.addon_folder,
+ vg_list_size(workshop_form.addon_folder), 1,
+ 0, &callbacks );
- if( ui_button_text( file_button, "Load", 1 ) ){
- workshop_op_load_model();
+ if( ui_button_text( ctx, file_button, "Load", 1 ) == 1 )
+ {
+ workshop_op_load_model( ctx );
}
}
}
- ui_rect title_entry, label;
- ui_split( content, k_ui_axis_h, 8, 0, null, content );
- ui_split( content, k_ui_axis_h, 28, 0, title_entry, content );
-
const char *str_title = "Title:", *str_desc = "Description:";
- ui_split( title_entry, k_ui_axis_v,
- ui_text_line_width(str_title)+8, 0, label, title_entry );
-
- ui_rect vis_dropdown;
- ui_split_ratio( title_entry, k_ui_axis_v, 0.6f, 16,
- title_entry, vis_dropdown );
/* title box */
{
struct ui_textbox_callbacks callbacks = {
.change = workshop_changed_title
};
- ui_text( label, str_title, 1, k_ui_align_middle_left, 0 );
- ui_textbox( title_entry, workshop_form.submission.title,
- vg_list_size(workshop_form.submission.title), 0, &callbacks );
+ ui_textbox( ctx, content, str_title, workshop_form.submission.title,
+ vg_list_size(workshop_form.submission.title), 1,
+ 0, &callbacks );
}
/* visibility option */
{
- ui_enum( vis_dropdown, "Visibility:", workshop_form_visibility_opts,
+ ui_enum( ctx, content, "Visibility:", workshop_form_visibility_opts,
4, &workshop_form.submission.visibility );
}
/* description box */
{
- struct ui_textbox_callbacks callbacks = {
+ struct ui_textbox_callbacks callbacks =
+ {
.change = workshop_changed_description
};
- ui_rect desc_entry;
- ui_split( content, k_ui_axis_h, 8, 0, null, content );
- ui_split( content, k_ui_axis_h, 28, 0, label, content );
- ui_split( content, k_ui_axis_h, 28*4, 0, desc_entry, content );
- ui_text( label, str_desc, 1, k_ui_align_middle_left, 0 );
- ui_textbox( desc_entry, workshop_form.submission.description,
- vg_list_size(workshop_form.submission.description),
- UI_TEXTBOX_MULTILINE|UI_TEXTBOX_WRAP, &callbacks );
+ ui_textbox( ctx, content, str_desc, workshop_form.submission.description,
+ vg_list_size(workshop_form.submission.description), 4,
+ UI_TEXTBOX_MULTILINE|UI_TEXTBOX_WRAP, &callbacks );
}
/* submissionable */
- ui_rect submission_row;
- ui_split( content, k_ui_axis_h, 8, 0, null, content );
- ui_split( content, k_ui_axis_h, content[3]-32-8, 0, content,
- submission_row );
+ ui_rect final_row;
+ ui_split( content, k_ui_axis_h, content[3]-32-8, 0, content, final_row );
ui_rect submission_center;
- rect_copy( submission_row, submission_center );
+ rect_copy( final_row, submission_center );
submission_center[2] = 256;
- ui_rect_center( submission_row, submission_center );
+ ui_rect_center( final_row, submission_center );
ui_rect btn_left, btn_right;
ui_split_ratio( submission_center, k_ui_axis_v, 0.5f, 8,
btn_left, btn_right );
- if( ui_button_text( btn_left, "Publish", 1 ) ){
- workshop_op_submit();
+ if( ui_button_text( ctx, btn_left, "Publish", 1 ) == 1 )
+ {
+ workshop_op_submit( ctx );
}
- if( ui_button_text( btn_right, "Cancel", 1 ) ){
+ if( ui_button_text( ctx, btn_right, "Cancel", 1 ) == 1 )
+ {
workshop_form.page = k_workshop_form_open;
player_board_unload( &workshop_form.board_model );
workshop_form.file_intent = k_workshop_form_file_intent_none;
"By submitting this item, you agree to the workshop terms of service";
ui_rect disclaimer_row, inner, link;
- ui_split( content, k_ui_axis_h, 8, 0, null, content );
- ui_split( content, k_ui_axis_h, content[3]-32, 0, content,
- disclaimer_row );
+ ui_split( content, k_ui_axis_h, content[3]-32, 0, content, disclaimer_row );
ui_px btn_width = 32;
rect_copy( disclaimer_row, inner );
- inner[2] = ui_text_line_width( disclaimer_text ) + btn_width+8;
+ inner[2] = ui_text_line_width( ctx, disclaimer_text ) + btn_width+8;
+ ui_rect label;
ui_rect_center( disclaimer_row, inner );
ui_split( inner, k_ui_axis_v, inner[2]-btn_width, 0, label, btn_right);
ui_rect_pad( btn_right, (ui_px[2]){2,2} );
- if( ui_button_text( btn_right, "\xbf", 2 ) ){
+ if( ui_button_text( ctx, btn_right, "\xb2", 2 ) == 1 )
+ {
ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage( hSteamFriends,
"https://steamcommunity.com/sharedfiles/workshoplegalagreement",
k_EActivateGameOverlayToWebPageMode_Default );
}
- ui_text( label, disclaimer_text, 1, k_ui_align_middle_left,
- ui_colour( k_ui_fg+4 ) );
+ ui_text( ctx, label, disclaimer_text, 1, k_ui_align_middle_left,
+ ui_colour( ctx, k_ui_fg+4 ) );
}
-VG_STATIC void workshop_form_gui_sidebar( ui_rect sidebar )
+static void workshop_form_gui_sidebar( ui_context *ctx, ui_rect sidebar )
{
- ui_fill( sidebar, ui_colour( k_ui_bg+2 ) );
+ ui_fill( ctx, sidebar, ui_colour( ctx, k_ui_bg+2 ) );
ui_rect title;
ui_split( sidebar, k_ui_axis_h, 28, 0, title, sidebar );
- if( workshop_form.page == k_workshop_form_edit ){
- ui_text( title, "Editing", 1, k_ui_align_middle_center, 0 );
+ if( workshop_form.page == k_workshop_form_edit )
+ {
+ ui_text( ctx, title, "Editing", 1, k_ui_align_middle_center, 0 );
ui_split( sidebar, k_ui_axis_h, 28, 0, title, sidebar );
- if( workshop_form.submission.type != k_addon_type_none ){
+ if( workshop_form.submission.type != k_addon_type_none )
+ {
char buf[512];
vg_str str;
vg_strnull( &str, buf, 512 );
else
vg_strcat( &str, "???." );
- ui_text( title, buf, 1, k_ui_align_middle_center,
- ui_colour(k_ui_fg+4) );
+ ui_text( ctx, title, buf, 1, k_ui_align_middle_center,
+ ui_colour(ctx, k_ui_fg+4) );
}
return;
}
/*
* sidebar existing entries panel
*/
- ui_text( title, "Your submissions", 1, k_ui_align_middle_center, 0 );
+ ui_text( ctx, title, "Your submissions", 1, k_ui_align_middle_center, 0 );
ui_rect controls, btn_create_new;
ui_split( sidebar, k_ui_axis_h, 32, 0, controls, sidebar );
ui_split( sidebar, k_ui_axis_h, -32, 0, sidebar, btn_create_new );
- ui_fill( controls, ui_colour( k_ui_bg+1 ) );
+ ui_fill( ctx, controls, ui_colour( ctx, k_ui_bg+1 ) );
char buf[32];
- strcpy( buf, "page " );
- int i = 5;
- i += highscore_intl( buf+i, workshop_form.view_published_page_id+1, 4 );
- buf[ i ++ ] = '/';
- i += highscore_intl( buf+i, workshop_form.view_published_page_count, 4 );
- buf[ i ++ ] = '\0';
+ vg_str str;
+ vg_strnull( &str, buf, sizeof(buf) );
+ vg_strcat( &str, "page " );
+ vg_strcati32( &str, workshop_form.view_published_page_id+1 );
+ vg_strcatch( &str, '/' );
+ vg_strcati32( &str, workshop_form.view_published_page_count );
ui_rect_pad( controls, (ui_px[2]){0,4} );
ui_rect info;
ui_split_ratio( controls, k_ui_axis_v, 0.25f, 0, info, controls );
- ui_text( info, buf, 1, k_ui_align_middle_center, 0 );
+ ui_text( ctx, info, buf, 1, k_ui_align_middle_center, 0 );
ui_rect btn_left, btn_right;
ui_split_ratio( controls, k_ui_axis_v, 0.5f, 2, btn_left, btn_right );
- if( ui_button_text( btn_left, "newer", 1 ) ){
+ if( ui_button_text( ctx, btn_left, "newer", 1 ) == 1 )
+ {
workshop_view_page( workshop_form.view_published_page_id-1 );
}
- if( ui_button_text( btn_right, "older", 1 ) ){
+ if( ui_button_text( ctx, btn_right, "older", 1 ) == 1 )
+ {
workshop_view_page( workshop_form.view_published_page_count+1 );
}
- if( ui_button_text( btn_create_new, "Create New Item", 1 ) ){
+ if( ui_button_text( ctx, btn_create_new, "Create New Item", 1 ) == 1 )
+ {
workshop_reset_submission_data();
workshop_form.submission.submit_title = 1;
workshop_form.submission.submit_description = 1;
workshop_form.page = k_workshop_form_edit;
}
- for( int i=0; i<workshop_form.published_files_list_length; i++ ){
+ for( int i=0; i<workshop_form.published_files_list_length; i++ )
+ {
ui_rect item;
ui_split( sidebar, k_ui_axis_h, 28, 0, item, sidebar );
ui_rect_pad( item, (ui_px[2]){4,4} );
struct published_file *pfile = &workshop_form.published_files_list[i];
- if( ui_button_text( item, pfile->title, 1 ) ){
- if( pfile->result == k_EResultOK ){
+ if( ui_button_text( ctx, item, pfile->title, 1 ) == 1 )
+ {
+ if( pfile->result == k_EResultOK )
+ {
vg_info( "Select index: %d\n", pfile->result_index );
workshop_op_download_and_view_submission( pfile->result_index );
}
- else{
+ else
+ {
vg_warn( "Cannot select that item, result not OK\n" );
}
}
}
}
-VG_STATIC void workshop_form_gui(void)
+void workshop_form_gui( ui_context *ctx )
{
enum workshop_form_page stable_page = workshop_form.page;
if( stable_page == k_workshop_form_hidden ) return;
ui_rect screen = { 0, 0, vg.window_x, vg.window_y };
ui_rect window = { 0, 0, 1000, 700 };
ui_rect_center( screen, window );
- vg_ui.wants_mouse = 1;
+ ctx->wants_mouse = 1;
- ui_fill( window, ui_colour( k_ui_bg+1 ) );
- ui_outline( window, 1, ui_colour( k_ui_bg+7 ) );
+ ui_fill( ctx, window, ui_colour( ctx, k_ui_bg+1 ) );
+ ui_outline( ctx, window, 1, ui_colour( ctx, k_ui_bg+7 ), 0 );
ui_rect title, panel;
ui_split( window, k_ui_axis_h, 28, 0, title, panel );
- ui_fill( title, ui_colour( k_ui_bg+7 ) );
- ui_text( title, "Workshop tool", 1, k_ui_align_middle_center,
- ui_colourcont(k_ui_bg+7) );
+ ui_fill( ctx, title, ui_colour( ctx, k_ui_bg+7 ) );
+ ui_text( ctx, title, "Workshop tool", 1, k_ui_align_middle_center,
+ ui_colourcont( ctx, k_ui_bg+7 ) );
ui_rect quit_button;
ui_split( title, k_ui_axis_v, title[2]-title[3], 2, title, quit_button );
- if( vg_loader_availible() ){
- if( ui_button_text( quit_button, "X", 1 ) ){
+ if( vg_loader_availible() )
+ {
+ if( ui_button_text( ctx, quit_button, "X", 1 ) == 1 )
+ {
workshop_quit_form();
return;
}
* escapes here and we show them a basic string
*/
- if( workshop_form.op != k_workshop_op_none ){
+ if( workshop_form.op != k_workshop_op_none )
+ {
const char *op_string = "The programmer has not bothered to describe "
"the current operation that is running.";
- switch( workshop_form.op ){
+ switch( workshop_form.op )
+ {
case k_workshop_op_loading_model:
op_string = "Operation in progress: Loading model file.";
break;
default: break;
}
- ui_text( panel, op_string, 1, k_ui_align_middle_center, 0 );
+ ui_text( ctx, panel, op_string, 1, k_ui_align_middle_center, 0 );
return;
}
/* content page */
ui_rect_pad( content, (ui_px[2]){8,8} );
- if( stable_page == k_workshop_form_edit ){
- workshop_form_gui_edit_page( content );
+ if( stable_page == k_workshop_form_edit )
+ {
+ workshop_form_gui_edit_page( ctx, content );
}
- else if( stable_page == k_workshop_form_open ){
- ui_text( content, "Nothing selected.", 1, k_ui_align_middle_center,
- ui_colour( k_ui_fg+4 ) );
+ else if( stable_page == k_workshop_form_open )
+ {
+ ui_text( ctx, content, "Nothing selected.", 1, k_ui_align_middle_center,
+ ui_colour( ctx, k_ui_fg+4 ) );
}
- else if( stable_page >= k_workshop_form_cclosing ){
+ else if( stable_page >= k_workshop_form_cclosing )
+ {
ui_rect submission_row;
ui_split( content, k_ui_axis_h, content[3]-32-8, 0, content,
submission_row );
u32 colour;
if( stable_page == k_workshop_form_closing_bad )
- colour = ui_colour( k_ui_red+k_ui_brighter );
+ colour = ui_colour( ctx, k_ui_red+k_ui_brighter );
else
- colour = ui_colour( k_ui_green+k_ui_brighter );
+ colour = ui_colour( ctx, k_ui_green+k_ui_brighter );
- ui_text( content, workshop_form.failure_or_success_string, 1,
+ ui_text( ctx, content, workshop_form.failure_or_success_string, 1,
k_ui_align_middle_center, colour );
ui_rect submission_center;
ui_rect_center( submission_row, submission_center );
ui_rect_pad( submission_center, (ui_px[2]){8,8} );
- if( ui_button_text( submission_center, "OK", 1 ) ){
+ if( ui_button_text( ctx, submission_center, "OK", 1 ) == 1 )
+ {
workshop_form.page = k_workshop_form_open;
}
}
- workshop_form_gui_sidebar( sidebar );
+ workshop_form_gui_sidebar( ctx, sidebar );
}
/*
* -----------------------------------------------------------------------------
*/
-VG_STATIC void async_workshop_get_filepath( void *data, u32 len )
+void async_workshop_get_filepath( void *data, u32 len )
{
struct async_workshop_filepath_info *info = data;
}
}
-VG_STATIC void async_workshop_get_installed_files( void *data, u32 len )
+void async_workshop_get_installed_files( void *data, u32 len )
{
struct async_workshop_installed_files_info *info = data;
*info->len = j;
}
-
-#endif /* WORKSHOP_C */
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff