#include "vg/vg.h"
#include "vg/vg_tex.h"
#include "vg/vg_msg.h"
+#include "vg/vg_binstr.h"
#include "ent_skateshop.h"
#include "vg/vg_steam_auth.h"
/*
* 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';
/*
* 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/";
* 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();
* 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 );
/*
* 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_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;
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(void){
/* TODO: Show these errors to the user */
if( workshop_form.submission.submit_title ){
if( !workshop_form.submission.title[0] ){
/*
* 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(void){
world_instance *world = world_current_instance();
workshop_form.view_world = world;
/*
* 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 =
/*
* 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 );
/*
* 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();
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_getkvu32( &msg, "type", 0 );
workshop_form.submission.type = type;
workshop_form.submission.submission_type_selection = type;
- const char *kv_folder = vg_msg_seekkvstr( &workshop, "folder",
- k_vg_msg_first );
+ 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),
/*
* 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 ){
vg_error( "Tried to change page without complete data\n" );
/*
* 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;
/*
* Console command to open the workshop publisher
*/
-VG_STATIC int workshop_submit_command( int argc, const char *argv[] )
+static int workshop_submit_command( int argc, const char *argv[] )
{
if( !steam_ready ){
ui_start_modal( "Steam API is not initialized\n", UI_MODAL_BAD );
return 0;
}
-VG_STATIC void workshop_init(void)
+static void workshop_init(void)
{
vg_console_reg_cmd( "workshop_submit", workshop_submit_command, NULL );
}
-VG_STATIC void workshop_render_world_preview(void){
+static void workshop_render_world_preview(void){
render_fb_bind( gpipeline.fb_workshop_preview, 0 );
glClearColor( 0.0f, 0.0f, 0.3f, 1.0f );
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
- render_world( localplayer.viewable_world, &skaterift.cam, 1 );
+ render_world( world_current_instance(), &skaterift.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){
+static void workshop_render_player_preview(void){
render_fb_bind( gpipeline.fb_workshop_preview, 0 );
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 );
+ 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 );
camera cam;
v3_copy( (v3f){ 0.0f, 201.7f, 1.2f }, cam.pos );
camera_update_projection( &cam );
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){
+static void workshop_render_board_preview(void){
if( !workshop_form.ptr_ent ){
return;
}
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;
glBufferSubData( GL_UNIFORM_BUFFER, 0,
sizeof(struct ub_world_lighting), &world->ub_lighting );
- render_world( world, &cam, 1 );
+ render_world( world, &cam, 0, 0, 1, 1 );
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( 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( 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( 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_rect content ){
ui_rect box;
rect_copy( content, box );
box[3] = 128;
}
}
-VG_STATIC void workshop_form_gui_draw_preview( ui_rect img_box ){
+static void workshop_form_gui_draw_preview( 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 );
}
}
-VG_STATIC void workshop_form_gui_edit_page( ui_rect content ){
+static void workshop_form_gui_edit_page( ui_rect content ){
enum addon_type type = workshop_form.submission.type;
if( type == k_addon_type_none ){
ui_colour( k_ui_fg+4 ) );
}
-VG_STATIC void workshop_form_gui_sidebar( ui_rect sidebar )
+static void workshop_form_gui_sidebar( ui_rect sidebar )
{
ui_fill( sidebar, ui_colour( k_ui_bg+2 ) );
}
}
-VG_STATIC void workshop_form_gui(void)
+static void workshop_form_gui(void)
{
enum workshop_form_page stable_page = workshop_form.page;
if( stable_page == k_workshop_form_hidden ) return;
* -----------------------------------------------------------------------------
*/
-VG_STATIC void async_workshop_get_filepath( void *data, u32 len )
+static 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 )
+static void async_workshop_get_installed_files( void *data, u32 len )
{
struct async_workshop_installed_files_info *info = data;