// Copyright (C) 2021 Harry Godden (hgn) - All Rights Reserved
+#define MARBLE_COMP_VERSION 4
//#define VG_CAPTURE_MODE
-//#define VG_STEAM
#define VG_STEAM_APPID 1218140U
#include "vg/vg.h"
enum e_game_state
{
k_game_state_main,
- k_game_state_settings
+ k_game_state_settings,
+ k_game_state_update
};
#define FLAG_CANAL 0x1
#define FLAG_FLIP_ROTATING 0x400
#define FLAG_TARGETED 0x800
+#define FLAG_INPUT_NICE 0x1000
+
/*
0000 0 | 0001 1 | 0010 2 | 0011 3
| | | | |
int is_linear;
v2f trigger_pos;
+ enum sprites_auto_combine_index trigger_sprite;
}
cell_descriptions[] =
{
// 0-3
- {},
- { .start = { 1, 0 }, .end = { -1, 0 }, .trigger_pos = { 0.5f, 0.25f } },
- { .start = { 0, 1 }, .end = { 0, -1 }, .trigger_pos = { 0.25f, 0.5f } },
- { .start = { 0, 1 }, .end = { 1, 0 }, .trigger_pos = { 0.25f, 0.25f } },
+ { .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d },
+ { .start = { 1, 0 }, .end = { -1, 0 }, .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d },
+ { .start = { 0, 1 }, .end = { 0, -1 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l },
+ { .start = { 0, 1 }, .end = { 1, 0 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l },
// 4-7
- { .start = { -1, 0 }, .end = { 1, 0 }, .trigger_pos = { 0.5f, 0.25f } },
- { .start = { -1, 0 }, .end = { 1, 0 }, .trigger_pos = { 0.5f, 0.25f }, .is_linear = 1 },
- { .start = { 0, 1 }, .end = { -1, 0 }, .trigger_pos = { 0.5f, 0.25f } },
+ { .start = { -1, 0 }, .end = { 1, 0 }, .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d },
+ { .start = { -1, 0 }, .end = { 1, 0 }, .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d, .is_linear = 1 },
+ { .start = { 0, 1 }, .end = { -1, 0 }, .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d },
{ .start = { 0, 1 }, .is_special = 1 },
// 8-11
- { .start = { 0, -1 }, .end = { 0, 1 }, .trigger_pos = { 0.25f, 0.5f } },
- { .start = { 1, 0 }, .end = { 0, -1 }, .trigger_pos = { 0.25f, 0.75f } },
- { .start = { 0, 1 }, .end = { 0, -1 }, .trigger_pos = { 0.25f, 0.5f }, .is_linear = 1 },
+ { .start = { 0, -1 }, .end = { 0, 1 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l },
+ { .start = { 1, 0 }, .end = { 0, -1 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l },
+ { .start = { 0, 1 }, .end = { 0, -1 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l, .is_linear = 1 },
{ },
// 12-15
- { .start = { -1, 0 }, .end = { 0, -1 }, .trigger_pos = { 0.75f, 0.75f } },
- { .end = { 0, -1 }, .is_special = 1, .trigger_pos = { 0.5f, 0.75f } },
+ { .start = { -1, 0 }, .end = { 0, -1 }, .trigger_pos = { 0.5f, 0.75f }, .trigger_sprite = k_sprite_brk_u },
+ { .end = { 0, -1 }, .is_special = 1, .trigger_pos = { 0.5f, 0.75f }, .trigger_sprite = k_sprite_brk_u },
{ },
{ }
};
u32 elements;
};
-struct
-{
- GLuint vao;
- GLuint vbo;
- GLuint ebo;
-
- u32
- title_start, title_count,
- desc_start, desc_count,
- score_start, score_count,
- time_start, time_count,
- grid_start, grid_count
- ;
-
- #pragma pack(push,1)
- struct vector_glyph_vert
- {
- v2f co;
- v2f uv;
-
- u32 colour;
- }
- *buffer;
- #pragma pack(pop)
-
- u16 *indices;
-}
-text_buffers;
-
static struct world
{
// Things that are 'static', aka, initialized once
float lvl_load_time;
float world_transition;
+ ui_ctx world_text;
}
st;
-#pragma pack(push,1)
struct cell
{
u16 state;
u16 links[2];
u8 config;
- char cc;
+ i8 emit[2];
}
*data;
-#pragma pack(pop)
struct render_cmd
{
{
struct terminal_run
{
- char conditions[8];
- char recieved[8];
+ i8 steps[8];
+ i8 recieved[8];
- int condition_count, recv_count;
+ int step_count, recv_count;
}
runs[8];
v2i pos;
v2i dir;
enum e_fish_state state;
- char payload;
+ i8 colour;
int flow_reversed;
float death_time;
v2f physics_v;
{ .mode = k_world_button_mode_toggle },
{ .mode = k_world_button_mode_toggle },
{ .mode = k_world_button_mode_toggle } }
- }
+ },
+ .selected = -1
};
// Forward declerations
// Utility functions
// -----------------
-static void colour_code_v3( char const cc, v3f target );
+static void colour_code_v3( i8 cc, v3f target );
static int hash21i( v2i p, u32 umod );
// Mesh functions
static struct cell *pcell( v2i pos );
static void lcell( int id, v2i pos );
static void map_reclassify( v2i start, v2i end, int update_texbuffer );
-static u32 gen_text_buffer( const char *str, struct sdf_font *font, v2f origin, float size, u32 start );
-static void gen_level_text( struct cmp_level *pLevel );
+static void gen_level_text(void);
static int map_load( const char *str, const char *name );
static void map_serialize( FILE *stream );
}
world_themes[] =
{
- {
- "Wood",
- { 0.89f, 0.8f, 0.7f },
- &tex_tiles_wood
- },
{
"Minimal",
{ 0.8f, 0.8f, 0.8f },
&tex_tiles_min
},
+ {
+ "Wood",
+ { 0.89f, 0.8f, 0.7f },
+ &tex_tiles_wood
+ },
{
"Lab",
{ 0.7f, 0.7f, 0.7f },
}
};
-static void colour_code_v3( char const cc, v3f target )
+static void colour_code_v3( i8 cc, v3f target )
{
- if( cc >= 'a' && cc <= 'z' )
- {
- int id = cc - 'a';
-
- if( id < vg_list_size( colour_sets[0] ) )
- {
- v3_copy( colour_sets[colour_set_id][ id ], target );
- return;
- }
- }
+ if( (cc >= 0) && (cc < vg_list_size( colour_sets[0] )) )
+ {
+ v3_copy( colour_sets[colour_set_id][ cc ], target );
+ return;
+ }
+ vg_error( "Invalid colour code used '%d'\n", (int)cc );
v3_copy( (v3f){0.0f,0.0f,0.0f}, target );
}
arrfree( world.io );
free( world.cmd_buf_tiles );
-
+ world.cmd_buf_tiles = NULL;
+
world.w = 0;
world.h = 0;
world.data = NULL;
if( cell->state & FLAG_WALL )
height = 0xFF-0x3F + hash21i( (v2i){x,y}, 0x3F );
- config = 0xF;
+ config = cell->state & FLAG_INPUT_NICE? 0xB: 0xF;
}
pcell((v2i){x,y})->config = config;
}
}
-static u32 gen_text_buffer( const char *str, struct sdf_font *font, v2f origin, float size, u32 start )
+static void gen_level_text(void)
{
- u32 count = 0;
+ // Old style UI.
+ ui_px const unit_scale_px = 4*UI_GLYPH_SPACING_X; // 4 char per unit
+ ui_begin( &world.st.world_text, world.w*unit_scale_px, world.h*unit_scale_px );
+
+ if( world.pCmpLevel )
+ {
+ for( int i = 0; i < vg_list_size( world.pCmpLevel->strings ); i ++ )
+ {
+ struct world_string *wstr = &world.pCmpLevel->strings[i];
- v2f cursor;
- v2f invUv;
- v2_copy( origin, cursor );
-
- float invScale = (size / (float)font->size);
- invUv[0] = 1.0f / (float)font->width;
- invUv[1] = 1.0f / (float)font->height;
-
- u16 base_idx = start * 4;
-
- const char *_c = str;
- char c;
- while( (c = *(_c ++)) )
- {
- if( c == '\n' )
- {
- cursor[1] -= size * 1.25f;
- cursor[0] = origin[0];
- }
- else if( c >= 32 && c <= 126 )
- {
- struct sdf_char *pch = &font->characters[ c - ' ' ];
- struct vector_glyph_vert *vt = &text_buffers.buffer[ count * 4 ];
- u16 *ind = &text_buffers.indices[ count * 6 ];
-
- // Emit quad
- v2f p0; v2f uv0;
- v2f p1; v2f uv1;
-
- v2_muladds( cursor, (v2f){ pch->originX, -pch->originY }, -invScale, p0 );
- v2_muladds( p0, (v2f){ pch->w, -pch->h }, invScale, p1 );
-
- v2_mul( (v2f){ pch->uvx, pch->uvy }, invUv, uv0 );
- v2_muladd( uv0, (v2f){ pch->w, pch->h }, invUv, uv1 );
-
- v2_copy( p0, vt[0].co );
- v2_copy( uv0, vt[0].uv );
- vt[0].colour = 0xffffffff;
-
- v2_copy( (v2f){ p0[0], p1[1] }, vt[1].co );
- v2_copy( (v2f){ uv0[0], uv1[1] }, vt[1].uv );
- vt[1].colour = 0xffffffff;
-
- v2_copy( p1, vt[2].co );
- v2_copy( uv1, vt[2].uv );
- vt[2].colour = 0xffffffff;
-
- v2_copy( (v2f){ p1[0], p0[1] }, vt[3].co );
- v2_copy( (v2f){ uv1[0], uv0[1] }, vt[3].uv );
- vt[3].colour = 0xffffffff;
-
- // Emit indices
- ind[0] = base_idx+count*4;
- ind[1] = base_idx+count*4+1;
- ind[2] = base_idx+count*4+2;
- ind[3] = base_idx+count*4;
- ind[4] = base_idx+count*4+2;
- ind[5] = base_idx+count*4+3;
-
- cursor[0] += (float)pch->advance * invScale;
- count ++;
- }
- }
-
- glBindVertexArray( text_buffers.vao );
-
- glBindBuffer( GL_ARRAY_BUFFER, text_buffers.vbo );
- glBufferSubData( GL_ARRAY_BUFFER,
- start*4*sizeof( struct vector_glyph_vert ),
- count*4*sizeof( struct vector_glyph_vert ),
- text_buffers.buffer
- );
-
- glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, text_buffers.ebo );
- glBufferSubData( GL_ELEMENT_ARRAY_BUFFER, start*6*sizeof(u16), count*6*sizeof(u16), text_buffers.indices );
-
- return count;
-}
+ if( wstr->str )
+ {
+ ui_px pos[2];
-static void gen_level_text( struct cmp_level *pLevel )
-{
- text_buffers.title_count = gen_text_buffer( pLevel->title, &font_Ubuntu, (v2f){ -5.0f, -0.6f }, 0.6f, text_buffers.title_start );
- text_buffers.desc_count = gen_text_buffer( pLevel->description, &font_Ubuntu, (v2f){ -5.0, -0.9f }, 0.25f, text_buffers.desc_start );
+ pos[0] = -UI_GLYPH_SPACING_X/2;
+
+ if( wstr->placement == k_placement_bottom )
+ pos[1] = 2*-unit_scale_px;
+ else
+ pos[1] = (world.h-1)*-unit_scale_px -6;
+
+ ui_text( &world.st.world_text, pos, wstr->str, 1, k_text_align_left );
+ }
+ }
+ }
+
+ // re-create level scores
+ for( int i = 0; i < vg_list_size( career_packs ); i ++ )
+ {
+ struct career_level_pack *set = &career_packs[i];
+
+ ui_text( &world.st.world_text,
+ (ui_px [2]){
+ set->origin[0]*unit_scale_px,
+ -(set->origin[1]+set->dims[1]+1)*unit_scale_px + 18
+ },
+ set->title, 1, k_text_align_left );
+
+ for( int j = 0; j < set->count; j ++ )
+ {
+ struct cmp_level *lvl = &set->pack[j];
+
+ if( lvl->completed_score && !lvl->is_tutorial )
+ {
+ char num[10];
+ snprintf( num, 9, "%d", lvl->completed_score );
+
+ ui_text( &world.st.world_text,
+ (ui_px [2]){
+ lvl->btn.position[0]*unit_scale_px + unit_scale_px/2,
+ -lvl->btn.position[1]*unit_scale_px - unit_scale_px/2
+ },
+ num, 1, k_text_align_center );
+ }
+ }
+ }
+
+ //ui_text( &world.st.world_text, (ui_px [2]){ 0, 0 }, "Preview", 1, k_text_align_left );
+
+ ui_resolve( &world.st.world_text );
}
static int map_load( const char *str, const char *name )
{
- //TODO: It may be worthwhile, at this point, to switch to binary encoding for save data
-
map_free();
char const *c = str;
struct terminal_run *run = &terminal->runs[ terminal->run_count-1 ];
if( (*c >= 'a' && *c <= 'z') || *c == ' ' )
- {
- run->conditions[ run->condition_count ++ ] = *c;
+ {
+ i8 code = -1;
+ if( *c != ' ' )
+ code = *c - 'a';
+
+ run->steps[ run->step_count ++ ] = code;
}
else
{
}
else if( *c == ':' )
{
- terminal->runs[ terminal->run_count ].condition_count = 0;
+ terminal->runs[ terminal->run_count ].step_count = 0;
terminal->run_count ++;
world.max_runs = vg_max( world.max_runs, terminal->run_count );
}
term->pos[1] = world.h;
term->run_count = 1;
- term->runs[0].condition_count = 0;
+ term->runs[0].step_count = 0;
switch( *c )
{
reg_end ++;
}
+ else if( *c == '.' ) cell->state = FLAG_INPUT_NICE;
else if( *c == '#' ) cell->state = FLAG_WALL;
else if( ((u32)*c >= (u32)'A') && ((u32)*c <= (u32)'A'+0xf) )
{
c ++;
}
- // Fix emitter CC code
+ // Assign emitter codes
for( int i = 0; i < arrlen( world.io ); i ++ )
{
struct cell_terminal *term = &world.io[i];
if( cell->state & FLAG_EMITTER )
{
- cell->cc = term->runs[0].conditions[0];
+ if( (term->run_count > 0) && (term->runs[0].step_count >= 2) )
+ {
+ cell->emit[0] = term->runs[0].steps[0];
+ cell->emit[1] = term->runs[0].steps[1];
+ }
+ else
+ {
+ vg_error( "Emitter was not assigned emit values\n" );
+ goto IL_REG_ERROR;
+ }
}
}
}
}
+ // ==========================================================
+ // Successful load
+
vg_success( "Map '%s' loaded! (%u:%u)\n", name, world.w, world.h );
io_reset();
struct cell *cell = pcell( (v2i){ x, y } );
if( cell->state & FLAG_WALL ) fputc( '#', stream );
+ else if( cell->state & FLAG_INPUT_NICE ) fputc( '.', stream );
else if( cell->state & FLAG_INPUT ) fputc( '+', stream );
else if( cell->state & FLAG_OUTPUT ) fputc( '-', stream );
else if( cell->state & FLAG_EMITTER ) fputc( '*', stream );
{
struct terminal_run *run = &term->runs[j];
- for( int k = 0; k < run->condition_count; k ++ )
- fputc( run->conditions[k], stream );
+ for( int k = 0; k < run->step_count; k ++ )
+ {
+ i8 step = run->steps[k];
+ fputc( step == -1? ' ': ('a' + run->steps[k]), stream );
+ }
if( j < term->run_count-1 )
fputc( ':', stream );
struct dlevel_state
{
i32 score;
+
i32 unlocked;
i32 reserved[2];
}
return;
struct dcareer_state encoded;
- encoded.version = 2;
+ encoded.version = MARBLE_COMP_VERSION;
encoded.in_map = world.pCmpLevel? world.pCmpLevel->serial_id: -1;
memset( encoded.reserved, 0, sizeof( encoded.reserved ) );
dest->score = lvl->completed_score;
dest->unlocked = lvl->unlocked;
dest->reserved[0] = 0;
- dest->reserved[1] = 0;
+ dest->reserved[1] = 0;
}
}
static void career_pass_level( struct cmp_level *lvl, int score, int upload )
{
if( score > 0 )
- {
- if( score < lvl->completed_score || lvl->completed_score == 0 )
- {
- #ifdef VG_STEAM
- if( !lvl->is_tutorial && upload )
- leaderboard_set_score( lvl, score );
- #endif
-
- lvl->completed_score = score;
- }
+ {
+ lvl->completed_score = score;
+ gen_level_text();
- if( lvl->unlock ) career_unlock_level( lvl->unlock );
+ if( lvl->unlock )
+ career_unlock_level( lvl->unlock );
- #ifdef VG_STEAM
if( lvl->achievement )
- {
sw_set_achievement( lvl->achievement );
- }
// Check ALL maps to trigger master engineer
for( int i = 0; i < vg_list_size( career_packs ); i ++ )
}
sw_set_achievement( "MASTER_ENGINEER" );
- #endif
}
}
struct dlevel_state *src = &encoded.levels[lvl->serial_id];
if( src->unlocked ) career_unlock_level( lvl );
- if( src->score ) lvl->completed_score = src->score;
+ if( src->score )
+ {
+ lvl->completed_score = src->score;
+
+ // Apply unlocking to next levels in case there was an update
+ if( lvl->unlock )
+ career_unlock_level( lvl->unlock );
+ }
if( lvl->serial_id == encoded.in_map )
lvl_to_load = lvl;
if( console_changelevel( 1, &lvl_to_load->map_name ) )
{
world.pCmpLevel = lvl_to_load;
- gen_level_text( world.pCmpLevel );
+ gen_level_text();
}
career_load_success = 1;
+
+ if( encoded.version < MARBLE_COMP_VERSION || 1 )
+ world.st.state = k_game_state_update;
}
// MAIN GAMEPLAY
if( world.pCmpLevel )
{
world.pCmpLevel->completed_score = 0;
+ gen_level_text();
}
}
if( console_changelevel( 1, &world.st.lvl_to_load->map_name ) )
{
world.pCmpLevel = world.st.lvl_to_load;
- gen_level_text( world.pCmpLevel );
+ gen_level_text();
}
world.st.lvl_to_load = NULL;
m3x3_translate( m_view, origin_current );
m3x3_mul( m_projection, m_view, vg_pv );
vg_projection_update();
+
+ if( world.st.state == k_game_state_update )
+ return;
// Mouse input
// ========================================================================================================
struct terminal_run *run = &term->runs[ world.sim_run ];
if( run->recv_count < vg_list_size( run->recieved ) )
{
- if( fish->payload == run->conditions[ run->recv_count ] )
+ if( fish->colour == run->steps[ run->recv_count ] )
success_this_frame = 1;
else
failure_this_frame = 1;
- run->recieved[ run->recv_count ++ ] = fish->payload;
+ run->recieved[ run->recv_count ++ ] = fish->colour;
}
else
failure_this_frame = 1;
if( cell_entry->config == k_cell_type_con_r || cell_entry->config == k_cell_type_con_u
|| cell_entry->config == k_cell_type_con_l || cell_entry->config == k_cell_type_con_d )
{
- #ifdef VG_STEAM
sw_set_achievement( "CAN_DO_THAT" );
- #endif
fish->state = k_fish_state_soon_alive;
// Spawn new marble
if( (target_peice->state & FLAG_EMITTER) && !(target_peice->state & FLAG_TRIGGERED))
{
- struct fish *fish = &world.fishes[ world.num_fishes ];
- lcell( cell_current->links[trigger_id], fish->pos );
-
- fish->state = k_fish_state_soon_alive;
- fish->payload = target_peice->cc;
-
- if( target_peice->config != k_cell_type_stub )
- {
- struct cell_description *desc = &cell_descriptions[ target_peice->config ];
- v2i_copy( desc->start, fish->dir );
- fish->flow_reversed = 1;
-
- world.num_fishes ++;
- alive_count ++;
- }
+ if( world.num_fishes < vg_list_size( world.fishes ) )
+ {
+ struct fish *fish = &world.fishes[ world.num_fishes ];
+ lcell( cell_current->links[trigger_id], fish->pos );
+
+ fish->state = k_fish_state_soon_alive;
+ fish->colour = target_peice->emit[ trigger_id ];
+
+ if( target_peice->config != k_cell_type_stub )
+ {
+ struct cell_description *desc = &cell_descriptions[ target_peice->config ];
+ v2i_copy( desc->start, fish->dir );
+ fish->flow_reversed = 1;
+
+ world.num_fishes ++;
+ alive_count ++;
+ }
+ }
+ else
+ vg_warn( "Max marbles exceeded\n" );
}
else
{
if( collide_next_frame || collide_this_frame )
{
- #ifdef VG_STEAM
sw_set_achievement( "BANG" );
- #endif
// Shatter death (+0.5s)
float death_time = world.sim_internal_time + ( collide_this_frame? 0.0f: 0.5f );
if( is_input )
{
- if( world.sim_frame < term->runs[ world.sim_run ].condition_count )
+ if( world.sim_frame < term->runs[ world.sim_run ].step_count )
{
- char emit = term->runs[ world.sim_run ].conditions[ world.sim_frame ];
- if( emit == ' ' )
+ i8 emit = term->runs[ world.sim_run ].steps[ world.sim_frame ];
+ if( emit == -1 )
continue;
struct fish *fish = &world.fishes[ world.num_fishes ];
v2i_copy( term->pos, fish->pos );
fish->state = k_fish_state_alive;
- fish->payload = emit;
+ fish->colour = emit;
struct cell *cell_ptr = pcell( fish->pos );
if( cell_ptr->config != k_cell_type_stub )
- {
- struct cell_description *desc = &cell_descriptions[ cell_ptr->config ];
-
- v2i_copy( desc->start, fish->dir );
- fish->flow_reversed = 1;
-
- world.num_fishes ++;
- alive_count ++;
+ {
+ if( world.num_fishes < vg_list_size(world.fishes))
+ {
+ struct cell_description *desc = &cell_descriptions[ cell_ptr->config ];
+
+ v2i_copy( desc->start, fish->dir );
+ fish->flow_reversed = 1;
+
+ world.num_fishes ++;
+ alive_count ++;
+ }
+ else
+ vg_warn( "Max marbles exceeded\n" );
}
}
}
{
struct terminal_run *run = &term->runs[ world.sim_run ];
- if( run->recv_count == run->condition_count )
+ if( run->recv_count == run->step_count )
{
- for( int j = 0; j < run->condition_count; j ++ )
+ for( int j = 0; j < run->step_count; j ++ )
{
- if( run->recieved[j] != run->conditions[j] )
+ if( run->recieved[j] != run->steps[j] )
{
world.completed = 0;
break;
}
else
{
- #ifdef VG_STEAM
if( world.sim_run > 0 )
sw_set_achievement( "GOOD_ENOUGH" );
- #endif
vg_error( "Level failed :(\n" );
}
static void render_tile( v2i pos, struct cell *ptr, v4f const regular_colour, v4f const selected_colour )
{
int selected = world.selected == pos[1]*world.w + pos[0];
-
- int tile_offsets[][2] =
- {
- {2, 0}, {0, 3}, {0, 2}, {2, 2},
- {1, 0}, {2, 3}, {3, 2}, {1, 3},
- {3, 1}, {0, 1}, {1, 2}, {2, 1},
- {1, 1}, {3, 3}, {2, 1}, {2, 1}
- };
-
int uv[2];
- uv[0] = tile_offsets[ ptr->config ][0];
- uv[1] = tile_offsets[ ptr->config ][1];
+ uv[0] = ptr->config & 0x3;
+ uv[1] = ptr->config >> 2;
glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ),
(float)pos[0],
{
struct cell *cell = pcell((v2i){x,y});
- if( cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT|FLAG_EMITTER) )
+ if( cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT|FLAG_EMITTER|FLAG_INPUT_NICE) )
{
struct render_cmd *cmd;
- if( cell->config == k_cell_type_split || (cell->state & FLAG_EMITTER ) )
+ if(
+ (cell->config == k_cell_type_split && (cell->state & FLAG_CANAL))
+ || (cell->state & (FLAG_EMITTER|FLAG_IS_TRIGGER))
+ )
cmd = &world.cmd_buf_tiles[ world.max_commands - (++ world.tile_special_count) ];
else
cmd = &world.cmd_buf_tiles[ world.tile_count ++ ];
v2_copy( fish->physics_co, render_pos );
v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
- colour_code_v3( fish->payload, dot_colour );
+ colour_code_v3( fish->colour, dot_colour );
glUniform3fv( SHADER_UNIFORM( shader_ball, "uColour" ), 1, dot_colour );
glUniform3fv( SHADER_UNIFORM( shader_ball, "uOffset" ), 1, render_pos );
glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ),
(float)cmd->pos[0],
(float)cmd->pos[1] + 0.125f,
- cell->state & FLAG_TARGETED? 3.0f: 0.0f,
- 0.0f
+ cell->state & FLAG_TARGETED? 3.0f: 2.0f,
+ 3.0f
);
draw_mesh( 0, 2 );
}
if( vg_get_button_up( "primary" ) )
world_button_exec( NULL, NULL, NULL, NULL );
+ // I/O ARRAYS
+ // ========================================================================================================
+
+ //glEnable(GL_BLEND);
+ SHADER_USE( shader_tile_colour );
+ glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
+
+ for( int i = 0; i < arrlen( world.io ); i ++ )
+ {
+ struct cell_terminal *term = &world.io[ i ];
+ struct cell *cell = pcell(term->pos);
+
+ int is_input = cell->state & FLAG_INPUT;
+ v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
+
+ if( cell->state & FLAG_EMITTER )
+ {
+ for( int j = 0; j < 2; j ++ )
+ {
+ if( cell->emit[j] != -1 )
+ {
+ colour_code_v3( cell->emit[j], dot_colour );
+
+ glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ),
+ term->pos[0] + 0.25f + (float)j * 0.5f,
+ term->pos[1] + 0.25f,
+ 0.12f
+ );
+
+ glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
+ draw_mesh( filled_start, filled_count );
+ }
+ }
+ continue;
+ }
+
+ for( int k = 0; k < term->run_count; k ++ )
+ {
+ float arr_base = is_input? 1.2f: -0.2f,
+ run_offset = (is_input? 0.2f: -0.2f) * (float)k,
+ y_position = is_input?
+ (arr_base + (float)term->pos[1] + (float)(term->run_count-1)*0.2f) - run_offset:
+ (float)term->pos[1] + arr_base + run_offset;
+
+ v4f bar_colour;
+ int bar_draw = 0;
+
+ if( is_simulation_running() )
+ {
+ if( k == world.sim_run )
+ {
+ float a = fabsf(sinf( vg_time * 2.0f )) * 0.075f + 0.075f;
+
+ v4_copy( (v4f){ 1.0f, 1.0f, 1.0f, a }, bar_colour );
+ }
+ else
+ v4_copy( (v4f){ 0.0f, 0.0f, 0.0f, 0.13f }, bar_colour );
+
+ bar_draw = 1;
+ }
+ else if( 1 || k & 0x1 )
+ {
+ if( k & 0x1 )
+ v4_copy( (v4f){ 1.0f, 1.0f, 1.0f, 0.07f }, bar_colour );
+ else
+ v4_copy( (v4f){ 0.0f, 0.0f, 0.0f, 0.13f }, bar_colour );
+
+ bar_draw = 1;
+ }
+
+ if( bar_draw )
+ {
+ glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, bar_colour );
+ glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ),
+ (float)term->pos[0], y_position - 0.1f, 1.0f );
+
+ draw_mesh( 2, 2 );
+ }
+
+ for( int j = 0; j < term->runs[k].step_count; j ++ )
+ {
+ glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ),
+ (float)term->pos[0] + 0.2f + 0.2f * (float)j,
+ y_position,
+ 0.1f
+ );
+
+ if( is_input )
+ {
+ i8 colour = term->runs[k].steps[j];
+ if( colour != -1 )
+ {
+ colour_code_v3( colour, dot_colour );
+ glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
+
+ // Draw filled if tick not passed, draw empty if empty
+ if( (world.sim_frame > j && world.sim_run >= k) || world.sim_run > k )
+ draw_mesh( empty_start, empty_count );
+ else
+ draw_mesh( filled_start, filled_count );
+ }
+ }
+ else
+ {
+
+ if( term->runs[k].recv_count > j )
+ {
+ colour_code_v3( term->runs[k].recieved[j], dot_colour );
+ v3_muls( dot_colour, 0.8f, dot_colour );
+ glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
+
+ draw_mesh( filled_start, filled_count );
+ }
+
+ colour_code_v3( term->runs[k].steps[j], dot_colour );
+ glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
+
+ draw_mesh( empty_start, empty_count );
+ }
+ }
+ }
+ }
+
// SPRITES
// ========================================================================================================
SHADER_USE( shader_sprite );
struct render_cmd *cmd = &world.cmd_buf_specials[i];
struct cell *cell = cmd->ptr;
- if( cell->config == k_cell_type_split )
+ if( (cell->config == k_cell_type_split) || (cell->state & FLAG_EMITTER) )
{
v2f center = { cmd->pos[0] + 0.5f, cmd->pos[1] + 0.5f };
render_sprite( k_sprite_jack_1, p0 );
render_sprite( k_sprite_jack_2, p1 );
}
+ else if( cell->state & FLAG_IS_TRIGGER )
+ {
+ v3f p0 = { 0.0f, 0.0f, 4.0f };
+
+ struct cell_description *desc = &cell_descriptions[ cell->config ];
+
+ v2_add( (v2f){ cmd->pos[0], cmd->pos[1] }, desc->trigger_pos, p0 );
+ render_sprite( desc->trigger_sprite, p0 );
+ }
}
// TEXT ELEMENTS
// ========================================================================================================
- SHADER_USE( shader_sdf );
- glBindVertexArray( text_buffers.vao );
- glUniformMatrix3fv( SHADER_UNIFORM( shader_sdf, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
-
- vg_tex2d_bind( &tex_ubuntu, 0 );
- glUniform1i( SHADER_UNIFORM( shader_sdf, "uTexGlyphs" ), 0 );
-
- glUniform4f( SHADER_UNIFORM( shader_sdf, "uColour" ), 1.0f, 1.0f, 1.0f, 1.0f );
- glDrawElements( GL_TRIANGLES, text_buffers.title_count*6, GL_UNSIGNED_SHORT, (void*)( text_buffers.title_start*6*sizeof(u16) ) );
- glDrawElements( GL_TRIANGLES, text_buffers.desc_count*6, GL_UNSIGNED_SHORT, (void*)( text_buffers.desc_start*6*sizeof(u16) ) );
-
- glUniform4f( SHADER_UNIFORM( shader_sdf, "uColour" ), 1.0f, 1.0f, 1.0f, 0.17f );
- glDrawElements( GL_TRIANGLES, text_buffers.grid_count*6, GL_UNSIGNED_SHORT, (void*)( text_buffers.grid_start*6*sizeof(u16) ) );
-
+ // Old style
+ m3x3f mvp_text;
+ m3x3_identity( mvp_text );
+ m3x3_scale( mvp_text, (v3f){
+ 1.0f/ ((float)UI_GLYPH_SPACING_X*4.0f),
+ 1.0f/ -((float)UI_GLYPH_SPACING_X*4.0f),
+ 1.0f
+ });
+
+ m3x3_mul( vg_pv, mvp_text, mvp_text );
+ ui_draw( &world.st.world_text, mvp_text );
+
// WIRES
// ========================================================================================================
- //glDisable(GL_BLEND);
+ glEnable(GL_BLEND);
SHADER_USE( shader_wire );
glBindVertexArray( world.wire.vao );
if( cmd->ptr->state & FLAG_EMITTER )
{
v4f wire_colour;
- colour_code_v3( other_cell->cc, wire_colour );
+ colour_code_v3( cmd->ptr->emit[j], wire_colour );
wire_colour[3] = 1.0f;
glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1, wire_colour );
// ========================================================================================================
SHADER_USE( shader_tile_colour );
- glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
use_mesh( &world.shapes );
for( int i = 0; i < world.tile_special_count; i ++ )
continue;
struct cell *other_cell = &world.data[ cell->links[ j ]];
-
struct cell_description *desc = &cell_descriptions[ other_cell->config ];
int x2 = cell->links[j] % world.w;
v2_add( desc->trigger_pos, pts[1], pts[1] );
- if( other_cell->state & FLAG_EMITTER )
+ if( cell->state & FLAG_EMITTER )
{
v4f wire_colour;
- colour_code_v3( other_cell->cc, wire_colour );
+ colour_code_v3( cell->emit[j], wire_colour );
v3_muls( wire_colour, 0.8f, wire_colour );
wire_colour[3] = 1.0f;
- glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1, wire_colour );
+ glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, wire_colour );
}
else
- {
- glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1, j? wire_right_colour: wire_left_colour );
- }
+ glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1,j?wire_right_colour: wire_left_colour );
for( int i = 0; i < 2; i ++ )
{
v2_add( center, (v2f){ -0.25f, -0.25f }, p0 );
v2_add( center, (v2f){ 0.25f, -0.25f }, p1 );
-
- if( cell->state & FLAG_FLIP_FLOP )
- render_sprite( k_sprite_flare_y, p1 );
- else
- render_sprite( k_sprite_flare_b, p0 );
+
+ if( cell->state & FLAG_TARGETED )
+ {
+ if( cell->state & FLAG_FLIP_FLOP )
+ render_sprite( k_sprite_flare_y, p1 );
+ else
+ render_sprite( k_sprite_flare_b, p0 );
+ }
+ else
+ render_sprite( k_sprite_flare_w, cell->state &FLAG_FLIP_FLOP? p1: p0 );
}
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendEquation(GL_FUNC_ADD);
- // I/O ARRAYS
- // ========================================================================================================
-
- //glEnable(GL_BLEND);
- SHADER_USE( shader_tile_colour );
-
- for( int i = 0; i < arrlen( world.io ); i ++ )
- {
- struct cell_terminal *term = &world.io[ i ];
-
- if( pcell(term->pos)->state & FLAG_EMITTER )
- continue;
-
- int is_input = pcell(term->pos)->state & FLAG_INPUT;
-
- v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
-
- for( int k = 0; k < term->run_count; k ++ )
- {
- float arr_base = is_input? 1.2f: -0.2f,
- run_offset = (is_input? 0.2f: -0.2f) * (float)k,
- y_position = is_input?
- (arr_base + (float)term->pos[1] + (float)(term->run_count-1)*0.2f) - run_offset:
- (float)term->pos[1] + arr_base + run_offset;
-
- v4f bar_colour;
- int bar_draw = 0;
-
- if( is_simulation_running() )
- {
- if( k == world.sim_run )
- {
- float a = fabsf(sinf( vg_time * 2.0f )) * 0.075f + 0.075f;
-
- v4_copy( (v4f){ 1.0f, 1.0f, 1.0f, a }, bar_colour );
- }
- else
- v4_copy( (v4f){ 0.0f, 0.0f, 0.0f, 0.13f }, bar_colour );
-
- bar_draw = 1;
- }
- else if( 1 || k & 0x1 )
- {
- if( k & 0x1 )
- v4_copy( (v4f){ 1.0f, 1.0f, 1.0f, 0.07f }, bar_colour );
- else
- v4_copy( (v4f){ 0.0f, 0.0f, 0.0f, 0.13f }, bar_colour );
-
- bar_draw = 1;
- }
-
- if( bar_draw )
- {
- glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, bar_colour );
- glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)term->pos[0], y_position - 0.1f, 1.0f );
- draw_mesh( 2, 2 );
- }
-
- for( int j = 0; j < term->runs[k].condition_count; j ++ )
- {
- glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ),
- (float)term->pos[0] + 0.2f + 0.2f * (float)j,
- y_position,
- 0.1f
- );
-
- if( is_input )
- {
- char cc = term->runs[k].conditions[j];
- if( cc != ' ' )
- {
- colour_code_v3( cc, dot_colour );
- glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
-
- // Draw filled if tick not passed, draw empty if empty
- if( (world.sim_frame > j && world.sim_run >= k) || world.sim_run > k )
- draw_mesh( empty_start, empty_count );
- else
- draw_mesh( filled_start, filled_count );
- }
- }
- else
- {
-
- if( term->runs[k].recv_count > j )
- {
- colour_code_v3( term->runs[k].recieved[j], dot_colour );
- v3_muls( dot_colour, 0.8f, dot_colour );
- glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
-
- draw_mesh( filled_start, filled_count );
- }
-
- colour_code_v3( term->runs[k].conditions[j], dot_colour );
- glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
-
- draw_mesh( empty_start, empty_count );
- }
- }
- }
- }
glDisable(GL_BLEND);
void vg_ui(void)
{
- if( world.st.state == k_game_state_settings )
+ // Drawing world name
+ if( world.pCmpLevel )
+ {
+ gui_text( (ui_px [2]){ vg_window_x / 2, 4 }, world.pCmpLevel->title, 2, k_text_align_center );
+ gui_text( (ui_px [2]){ vg_window_x / 2, 28 }, world.pCmpLevel->description, 1, k_text_align_center );
+ }
+
+ if( world.st.state == k_game_state_update )
+ {
+ gui_group_id( 34 );
+
+ ui_global_ctx.cursor[2] = 458;
+ ui_global_ctx.cursor[3] = 316;
+ ui_global_ctx.cursor[0] = vg_window_x / 2 - 229;
+ ui_global_ctx.cursor[1] = vg_window_y / 2 - 158;
+
+ gui_new_node();
+ {
+ gui_capture_mouse( 200 );
+ gui_fill_rect( ui_global_ctx.cursor, 0xE8303030 );
+
+ ui_px title_pos[2];
+ title_pos[0] = ui_global_ctx.cursor[0] + 229;
+ title_pos[1] = ui_global_ctx.cursor[1] + 16;
+
+ gui_text( title_pos, "Update 1.5", 2, k_text_align_center );
+
+ gui_text( (ui_px [2]){ ui_global_ctx.cursor[0] + 16, title_pos[1] + 45 },
+ "Welcome to the first update to marble computing!"
+ "\n"
+ "New features have been added:\n"
+ "\n"
+ " - Settings menu\n"
+ " - Map skins\n"
+ " - More levels and a new block type\n"
+ " - Scores for each level\n"
+ " - Zooming and panning (mousewheel)\n"
+ "\n"
+ "There is much more in the works, such as a\n"
+ "soundtrack, and the rest of the levels for the\n"
+ "3 bit computer!\n"
+ "\n"
+ "Thank you everyone for enjoying my game :)\n",
+ 1, k_text_align_left
+ );
+
+ ui_global_ctx.cursor[2] = 100;
+ ui_global_ctx.cursor[3] = 30;
+ ui_global_ctx.cursor[0] += 229 - 50;
+ ui_global_ctx.cursor[1] += 316 - 30 - 16;
+
+ if( gui_button( 1 ) )
+ {
+ world.st.state = k_game_state_main;
+ }
+ gui_text( (ui_px [2]){ ui_global_ctx.cursor[0] + 50,
+ ui_global_ctx.cursor[1] + 4 }, "OK", 1, k_text_align_center );
+ gui_end();
+ }
+ gui_end();
+ }
+ else if( world.st.state == k_game_state_settings )
{
gui_group_id( 35 );
gui_new_node();
{
- gui_text( "Settings", 3 );
+ gui_text( ui_global_ctx.cursor, "SETTINGS", 2, 0 );
}
gui_end();
// Colour scheme selection
ui_global_ctx.cursor[1] += 30;
- gui_text( "Colour Scheme", 2 );
+ gui_text( ui_global_ctx.cursor, "Colour Scheme", 1, 0 );
ui_global_ctx.cursor[1] += 25;
gui_new_node();
if( colour_set_id > 0 )
colour_set_id --;
}
- gui_text( "<", 2 );
+ gui_text( ui_global_ctx.cursor, "<", 2, 0 );
gui_end_right();
ui_global_ctx.cursor[2] = 150;
gui_new_node();
{
gui_fill_rect( ui_global_ctx.cursor, 0x33ffffff );
- ui_global_ctx.cursor[0] += 45;
- ui_global_ctx.cursor[1] += 6;
- gui_text( (const char *[]){ "Normal", "Extra1", "Extra2" }[ colour_set_id ], 2 );
+ gui_text(
+ (ui_px [2]){ ui_global_ctx.cursor[0] + 75, ui_global_ctx.cursor[1] + 6 },
+ (const char *[]){ "Normal", "Extra1", "Extra2" }[ colour_set_id ],
+ 1, k_text_align_center
+ );
}
gui_end_right();
if( colour_set_id < vg_list_size( colour_sets )-1 )
colour_set_id ++;
}
- gui_text( ">", 2 );
+ gui_text( ui_global_ctx.cursor, ">", 2, 0 );
gui_end_down();
}
gui_end_down();
// TODO: remove code dupe
ui_global_ctx.cursor[1] += 16;
- gui_text( "Tile Theme", 2 );
+ gui_text( ui_global_ctx.cursor, "Tile Theme", 1, 0 );
ui_global_ctx.cursor[1] += 20;
gui_new_node();
if( world_theme_id > 0 )
world_theme_id --;
}
- gui_text( "<", 2 );
+ gui_text( ui_global_ctx.cursor, "<", 2, 0 );
gui_end_right();
ui_global_ctx.cursor[2] = 150;
gui_new_node();
{
gui_fill_rect( ui_global_ctx.cursor, 0x33ffffff );
- ui_global_ctx.cursor[0] += 45;
- ui_global_ctx.cursor[1] += 6;
- gui_text( world_themes[ world_theme_id ].name, 2 );
+ gui_text(
+ (ui_px [2]){ ui_global_ctx.cursor[0] + 75, ui_global_ctx.cursor[1] + 6 },
+ world_themes[ world_theme_id ].name, 1, k_text_align_center
+ );
}
gui_end_right();
if( world_theme_id < vg_list_size( world_themes )-1 )
world_theme_id ++;
}
- gui_text( ">", 2 );
+ gui_text( ui_global_ctx.cursor, ">", 2, 0 );
gui_end_down();
}
gui_end_down();
vg_info( " miniaudio MIT0 miniaud.io\n" );
vg_info( " QOI MIT phoboslab.org\n" );
vg_info( " STB library MIT nothings.org\n" );
- vg_info( " Weiholmir JustFredrik\n" );
- vg_info( " Ubuntu Regular ubuntu.com\n" );
return 0;
}
resource_load_main();
- // Create text buffers
- {
- // Work out the counts for each 'segment'
- u32 desc_max_size = 0, title_max_size = 0,
- score_max_size = 10,
- time_max_size = 10,
-
- size_level_texts = 6*9*7
- ;
-
- for( int i = 0; i < vg_list_size( career_packs ); i ++ )
- {
- struct career_level_pack *set = &career_packs[i];
- for( int j = 0; j < set->count; j ++ )
- {
- struct cmp_level *lvl = &set->pack[j];
-
- desc_max_size = VG_MAX( desc_max_size, strlen( lvl->description ) );
- title_max_size = VG_MAX( title_max_size, strlen( lvl->title ) );
- }
- }
-
- // Full buffer
- u32 total_characters =
- title_max_size +
- desc_max_size +
- score_max_size +
- time_max_size +
- size_level_texts;
-
- u32 total_faces = total_characters * 2,
- total_vertices = total_characters * 4,
- total_indices = total_faces * 3;
-
- // Working buffer
- u32 work_buffer_total_chars =
- VG_MAX( 7, VG_MAX( VG_MAX( desc_max_size, title_max_size ), VG_MAX( score_max_size, time_max_size ) ) );
-
- u32 total_work_faces = work_buffer_total_chars * 2,
- total_work_vertices = work_buffer_total_chars * 4,
- total_work_indices = total_work_faces * 3;
-
- text_buffers.title_count = 0;
- text_buffers.desc_count = 0;
- text_buffers.score_count = 0;
- text_buffers.time_count = 0;
- text_buffers.grid_count = size_level_texts;
-
- // Calculate offsets
- text_buffers.title_start = 0;
- text_buffers.desc_start = text_buffers.title_start + title_max_size;
- text_buffers.score_start = text_buffers.desc_start + desc_max_size;
- text_buffers.time_start = text_buffers.score_start + score_max_size;
- text_buffers.grid_start = text_buffers.time_start + time_max_size;
-
- // Opengl
- glGenVertexArrays(1, &text_buffers.vao);
- glGenBuffers( 1, &text_buffers.vbo );
- glGenBuffers( 1, &text_buffers.ebo );
- glBindVertexArray( text_buffers.vao );
-
- glBindBuffer( GL_ARRAY_BUFFER, text_buffers.vbo );
- glBufferData( GL_ARRAY_BUFFER, total_vertices * sizeof( struct vector_glyph_vert ), NULL, GL_DYNAMIC_DRAW );
+ // Init world text
+ {
+ ui_init_context( &world.st.world_text, 15000 );
+ }
- glBindVertexArray( text_buffers.vao );
-
- glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, text_buffers.ebo );
- glBufferData( GL_ELEMENT_ARRAY_BUFFER, total_indices * sizeof( u16 ), NULL, GL_DYNAMIC_DRAW );
-
- u32 const stride = sizeof( struct vector_glyph_vert );
-
- // XY
- glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, stride, (void *)offsetof( struct vector_glyph_vert, co ) );
- glEnableVertexAttribArray( 0 );
-
- // UV
- glVertexAttribPointer( 1, 2, GL_FLOAT, GL_FALSE, stride, (void *)offsetof( struct vector_glyph_vert, uv ) );
- glEnableVertexAttribArray( 1 );
-
- // COLOUR
- glVertexAttribPointer( 2, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, (void *)offsetof( struct vector_glyph_vert, colour ) );
- glEnableVertexAttribArray( 2 );
-
- // Offline memory
- text_buffers.buffer = (struct vector_glyph_vert *)malloc( total_work_vertices * sizeof(struct vector_glyph_vert) );
- text_buffers.indices = (u16*)malloc( total_work_indices * sizeof(u16) );
-
- char label[8];
- for( int i = 1; i < 7; i ++ )
- label[i] = ' ';
- label[7] = 0x00;
-
- // Reset grid
- for( int x = 0; x < 6; x ++ )
- {
- for( int y = 0; y < 9; y ++ )
- {
- label[0] = ' ';
-
- if( x == 0 )
- {
- if( y != 8 )
- label[0] = 'A' + y;
- }
- else if( y == 8 )
- {
- label[0] = '0' + x;
- }
-
- gen_text_buffer( label, &font_Ubuntu, (v2f){ -6.0f + x + (x == 0? 0.6f: 0.2f), y + 0.2f }, 0.35f, text_buffers.grid_start+(y*6+x)*7 );
- }
- }
- }
-
// Restore gamestate
career_local_data_init();
career_load();
void vg_free(void)
{
-#ifdef VG_STEAM
- sw_free_opengl();
-#endif
-
console_save_map( 0, NULL );
career_serialize();
- glDeleteVertexArrays( 1, &text_buffers.vao );
- glDeleteBuffers( 1, &text_buffers.vbo );
- glDeleteBuffers( 1, &text_buffers.ebo );
-
- free( text_buffers.buffer );
- free( text_buffers.indices );
-
resource_free_main();
glDeleteTextures( 1, &world.background_data );
free_mesh( &world.shapes );
+ ui_context_free( &world.st.world_text );
+
map_free();
}
projects / fishladder.git / blobdiff