mirror of
https://github.com/Ed94/HandmadeHero.git
synced 2024-11-10 03:44:53 -08:00
1016 lines
31 KiB
C++
1016 lines
31 KiB
C++
#if INTELLISENSE_DIRECTIVES
|
|
#include "engine.hpp"
|
|
#include "engine_to_platform_api.hpp"
|
|
#include "handmade.hpp"
|
|
#endif
|
|
|
|
NS_ENGINE_BEGIN
|
|
|
|
#define pressed( btn ) (btn.ended_down && btn.half_transitions > 0)
|
|
|
|
// Used to determine if analog input is at move threshold
|
|
constexpr f32 analog_move_threshold = 0.5f;
|
|
|
|
struct EngineActions
|
|
{
|
|
b32 move_up;
|
|
b32 move_down;
|
|
b32 move_left;
|
|
b32 move_right;
|
|
|
|
b32 loop_mode_engine;
|
|
b32 loop_mode_game;
|
|
|
|
b32 raise_volume;
|
|
b32 lower_volume;
|
|
b32 raise_tone_hz;
|
|
b32 lower_tone_hz;
|
|
|
|
b32 toggle_wave_tone;
|
|
|
|
#if Build_Development
|
|
b32 pause_renderer;
|
|
|
|
b32 load_auto_snapshot;
|
|
b32 set_snapshot_slot_1;
|
|
b32 set_snapshot_slot_2;
|
|
b32 set_snapshot_slot_3;
|
|
b32 set_snapshot_slot_4;
|
|
|
|
b32 force_null_access_violation;
|
|
#endif
|
|
};
|
|
|
|
struct EngineState
|
|
{
|
|
f32 auto_snapshot_interval;
|
|
f32 auto_snapshot_timer;
|
|
|
|
s32 wave_tone_hz;
|
|
s32 tone_volume;
|
|
s32 x_offset;
|
|
s32 y_offset;
|
|
|
|
b32 renderer_paused;
|
|
|
|
f32 sample_wave_sine_time;
|
|
b32 sample_wave_switch;
|
|
|
|
hh::Memory game_memory;
|
|
};
|
|
|
|
NS_ENGINE_END
|
|
#include "test_samples.cpp"
|
|
NS_ENGINE_BEGIN
|
|
|
|
#if Build_Development
|
|
using SnapshotFn = void ( Memory* memory, platform::ModuleAPI* platform_api );
|
|
|
|
internal
|
|
void load_engine_snapshot( Memory* memory, platform::ModuleAPI* platform_api )
|
|
{
|
|
platform_api->memory_copy( memory->persistent, memory->total_size()
|
|
, memory->snapshots[ memory->active_snapshot_slot ].memory );
|
|
}
|
|
|
|
internal
|
|
void load_game_snapshot( Memory* memory, platform::ModuleAPI* platform_api )
|
|
{
|
|
s32 slot = memory->active_snapshot_slot;
|
|
EngineState* state = rcast( EngineState*, memory->persistent );
|
|
|
|
void* persistent_slot = memory->snapshots[ slot ].memory;
|
|
void* transient_slot = rcast( Byte*, memory->snapshots[ slot ].memory ) + state->game_memory.persistent_size;
|
|
|
|
platform_api->memory_copy( state->game_memory.persistent, state->game_memory.persistent_size, persistent_slot );
|
|
platform_api->memory_copy( state->game_memory.transient, state->game_memory.transient_size, transient_slot );
|
|
}
|
|
|
|
internal
|
|
void take_engine_snapshot( Memory* memory, platform::ModuleAPI* platform_api )
|
|
{
|
|
platform_api->memory_copy( memory->snapshots[ memory->active_snapshot_slot ].memory, memory->total_size(), memory->persistent );
|
|
memory->snapshots[ memory->active_snapshot_slot ].age = platform_api->get_wall_clock();
|
|
}
|
|
|
|
internal
|
|
void take_game_snapshot( Memory* memory, platform::ModuleAPI* platform_api )
|
|
{
|
|
s32 slot = memory->active_snapshot_slot;
|
|
EngineState* state = rcast( EngineState*, memory->persistent );
|
|
|
|
void* persistent_slot = memory->snapshots[ slot ].memory;
|
|
void* transient_slot = rcast( Byte*, memory->snapshots[ slot ].memory ) + state->game_memory.persistent_size;
|
|
|
|
platform_api->memory_copy( persistent_slot, state->game_memory.persistent_size, state->game_memory.persistent );
|
|
platform_api->memory_copy( transient_slot, state->game_memory.transient_size, state->game_memory.transient );
|
|
memory->snapshots[ memory->active_snapshot_slot ].age = platform_api->get_wall_clock();
|
|
}
|
|
|
|
internal
|
|
void begin_recording_input( Memory* memory, InputState* input, platform::ModuleAPI* platform_api )
|
|
{
|
|
Str file_name = str_ascii("test_input_");
|
|
StrPath file_path = {};
|
|
file_path.concat( platform_api->path_scratch, file_name );
|
|
snprintf( file_path.ptr, file_path.len, "%s%d.hm_replay", file_name.ptr, memory->active_snapshot_slot );
|
|
|
|
memory->active_input_replay_file.path = file_path;
|
|
platform_api->file_delete( memory->active_input_replay_file.path );
|
|
memory->replay_mode = ReplayMode_Record;
|
|
}
|
|
|
|
internal
|
|
void end_recording_input( Memory* memory, InputState* input, platform::ModuleAPI* platform_api )
|
|
{
|
|
memory->replay_mode = ReplayMode_Off;
|
|
platform_api->file_close( & memory->active_input_replay_file );
|
|
}
|
|
|
|
internal
|
|
void begin_playback_input( Memory* memory, InputState* input, platform::ModuleAPI* platform_api )
|
|
{
|
|
Str file_name = str_ascii("test_input_");
|
|
StrPath file_path = {};
|
|
file_path.concat( platform_api->path_scratch, file_name );
|
|
snprintf( file_path.ptr, file_path.len, "%s%d.hm_replay", file_name.ptr, memory->active_snapshot_slot );
|
|
|
|
// TODO(Ed - From Casey): Recording system still seems to take too long
|
|
// on record start - find out what Windows is doing and if
|
|
// we can speed up / defer some of that processing.
|
|
|
|
if ( platform_api->file_check_exists( file_path ) )
|
|
{
|
|
memory->active_input_replay_file.path = file_path;
|
|
memory->replay_mode = ReplayMode_Playback;
|
|
}
|
|
else
|
|
{
|
|
// TODO(Ed) : Logging
|
|
}
|
|
}
|
|
|
|
internal
|
|
void end_playback_input( Memory* memory, InputState* input, platform::ModuleAPI* platform_api )
|
|
{
|
|
memory->replay_mode = ReplayMode_Off;
|
|
platform_api->file_close( & memory->active_input_replay_file );
|
|
}
|
|
|
|
InputStateSnapshot input_state_snapshot( InputState* input )
|
|
{
|
|
InputStateSnapshot snapshot = {};
|
|
for ( s32 idx = 0; idx < array_count( snapshot.controllers ); ++ idx )
|
|
{
|
|
ControllerState* controller = & input->controllers[idx];
|
|
if ( controller == nullptr )
|
|
continue;
|
|
|
|
if ( controller->ds_pad )
|
|
snapshot.controllers[idx].ds_pad = *controller->ds_pad;
|
|
|
|
if ( controller->xpad )
|
|
snapshot.controllers[idx].xpad = *controller->xpad;
|
|
|
|
if ( controller->keyboard )
|
|
{
|
|
snapshot.controllers[idx].keyboard = *controller->keyboard;
|
|
}
|
|
|
|
if ( controller->mouse )
|
|
snapshot.controllers[idx].mouse = *controller->mouse;
|
|
}
|
|
return snapshot;
|
|
}
|
|
|
|
internal
|
|
void record_input( Memory* memory, InputState* input, platform::ModuleAPI* platform_api )
|
|
{
|
|
InputStateSnapshot snapshot = input_state_snapshot( input );
|
|
if ( platform_api->file_write_stream( & memory->active_input_replay_file, sizeof(snapshot), &snapshot ) == 0 )
|
|
{
|
|
// TODO(Ed) : Logging
|
|
}
|
|
}
|
|
|
|
internal
|
|
void play_input( SnapshotFn* load_snapshot, Memory* memory, InputState* input, platform::ModuleAPI* platform_api )
|
|
{
|
|
InputStateSnapshot new_input;
|
|
if ( platform_api->file_read_stream( & memory->active_input_replay_file, sizeof(InputStateSnapshot), & new_input ) == 0 )
|
|
{
|
|
load_snapshot( memory, platform_api );
|
|
platform_api->file_rewind( & memory->active_input_replay_file );
|
|
return;
|
|
}
|
|
|
|
for ( s32 idx = 0; idx < array_count( new_input.controllers ); ++ idx )
|
|
{
|
|
ControllerState* controller = & input->controllers[idx];
|
|
if ( controller == nullptr )
|
|
continue;
|
|
|
|
if ( controller->ds_pad )
|
|
*controller->ds_pad = new_input.controllers[idx].ds_pad;
|
|
|
|
if ( controller->xpad )
|
|
*controller->xpad = new_input.controllers[idx].xpad;
|
|
|
|
if ( controller->keyboard )
|
|
{
|
|
*controller->keyboard = new_input.controllers[idx].keyboard;
|
|
}
|
|
|
|
if ( controller->mouse )
|
|
*controller->mouse = new_input.controllers[idx].mouse;
|
|
}
|
|
}
|
|
|
|
void process_loop_mode( SnapshotFn* take_snapshot, SnapshotFn* load_snapshot
|
|
, Memory* memory, EngineState* state, InputState* input, platform::ModuleAPI* platform_api )
|
|
{
|
|
if ( memory->replay_mode == ReplayMode_Off )
|
|
{
|
|
take_snapshot( memory, platform_api );
|
|
begin_recording_input( memory, input, platform_api );
|
|
}
|
|
else if ( memory->replay_mode == ReplayMode_Playback )
|
|
{
|
|
end_playback_input( memory, input, platform_api );
|
|
load_snapshot( memory, platform_api );
|
|
}
|
|
else if ( memory->replay_mode == ReplayMode_Record )
|
|
{
|
|
end_recording_input( memory, input, platform_api );
|
|
load_snapshot( memory, platform_api );
|
|
begin_playback_input( memory, input, platform_api );
|
|
}
|
|
}
|
|
// Build_Development
|
|
#endif
|
|
|
|
internal
|
|
void input_poll_engine_actions( InputState* input, EngineActions* actions )
|
|
{
|
|
ControllerState* controller = & input->controllers[0];
|
|
KeyboardState* keyboard = controller->keyboard;
|
|
|
|
// actions->move_right |= keyboard->D.EndedDown;
|
|
// actions->move_left |= keyboard->A.EndedDown;
|
|
// actions->move_up |= keyboard->W.EndedDown;
|
|
// actions->move_down |= keyboard->S.EndedDown;
|
|
|
|
actions->raise_volume |= keyboard->up.ended_down;
|
|
actions->lower_volume |= keyboard->down.ended_down;
|
|
|
|
actions->raise_tone_hz |= keyboard->right.ended_down;
|
|
actions->lower_tone_hz |= keyboard->left.ended_down;
|
|
|
|
#if Build_Development
|
|
actions->pause_renderer |= pressed( keyboard->pause );
|
|
|
|
actions->set_snapshot_slot_1 |= pressed( keyboard->_1 ) && keyboard->right_alt.ended_down;
|
|
actions->set_snapshot_slot_2 |= pressed( keyboard->_2 ) && keyboard->right_alt.ended_down;
|
|
actions->set_snapshot_slot_3 |= pressed( keyboard->_3 ) && keyboard->right_alt.ended_down;
|
|
actions->set_snapshot_slot_4 |= pressed( keyboard->_4 ) && keyboard->right_alt.ended_down;
|
|
#endif
|
|
|
|
actions->toggle_wave_tone |= pressed( keyboard->Q );
|
|
|
|
actions->loop_mode_game |= pressed( keyboard->L ) && ! keyboard->right_shift.ended_down && ! keyboard->right_alt.ended_down;
|
|
actions->loop_mode_engine |= pressed( keyboard->L ) && keyboard->right_shift.ended_down;
|
|
|
|
MousesState* mouse = controller->mouse;
|
|
|
|
actions->move_right = (mouse->horizontal_wheel.end > 0.f) * 20;
|
|
actions->move_left = (mouse->horizontal_wheel.end < 0.f) * 20;
|
|
|
|
actions->move_up = (mouse->vertical_wheel.end > 0.f) * 10;
|
|
actions->move_down = (mouse->vertical_wheel.end < 0.f) * 10;
|
|
|
|
actions->load_auto_snapshot |= pressed( keyboard->L ) && keyboard->right_alt.ended_down;
|
|
}
|
|
|
|
internal
|
|
void input_poll_player_actions( InputState* input, hh::PlayerActions* actions )
|
|
{
|
|
ControllerState* controller = & input->controllers[0];
|
|
|
|
if ( controller->ds_pad )
|
|
{
|
|
DualsensePadState* pad = controller->ds_pad;
|
|
|
|
actions->jump |= pressed( pad->cross );
|
|
|
|
actions->player_x_move_analog += pad->stick.left.X.end;
|
|
actions->player_y_move_analog += pad->stick.left.Y.end;
|
|
}
|
|
if ( controller->xpad )
|
|
{
|
|
XInputPadState* pad = controller->xpad;
|
|
|
|
actions->jump |= pressed( pad->A );
|
|
|
|
actions->player_x_move_analog += pad->stick.left.X.end;
|
|
actions->player_y_move_analog += pad->stick.left.Y.end;
|
|
}
|
|
|
|
if ( controller->keyboard )
|
|
{
|
|
KeyboardState* keyboard = controller->keyboard;
|
|
actions->jump |= pressed( keyboard->space );
|
|
|
|
actions->player_x_move_digital += keyboard->D.ended_down - keyboard->A.ended_down;
|
|
actions->player_y_move_digital += keyboard->W.ended_down - keyboard->S.ended_down;
|
|
}
|
|
|
|
if ( controller->mouse )
|
|
{
|
|
MousesState* mouse = controller->mouse;
|
|
}
|
|
}
|
|
|
|
internal void
|
|
output_sound( EngineState* state, AudioBuffer* sound_buffer, GetSoundSampleValueFn* get_sample_value )
|
|
{
|
|
s16* sample_out = sound_buffer->samples;
|
|
for ( s32 sample_index = 0; sample_index < sound_buffer->num_samples; ++ sample_index )
|
|
{
|
|
s16 sample_value = get_sample_value( state, sound_buffer );
|
|
sound_buffer->running_sample_index++;
|
|
|
|
// char ms_timing_debug[256] {};
|
|
// wsprintfA( ms_timing_debug, "sample_value: %d\n", sample_value );
|
|
// d ms_timing_debug );
|
|
|
|
*sample_out = sample_value;
|
|
++ sample_out;
|
|
|
|
*sample_out = sample_value;
|
|
++ sample_out;
|
|
}
|
|
}
|
|
|
|
internal
|
|
void draw_rectangle( OffscreenBuffer* buffer
|
|
, f32 min_x, f32 min_y
|
|
, f32 max_x, f32 max_y
|
|
, f32 red, f32 green, f32 blue )
|
|
{
|
|
s32 min_x_32 = round_f32_to_s32( min_x );
|
|
s32 min_y_32 = round_f32_to_s32( min_y );
|
|
s32 max_x_32 = round_f32_to_s32( max_x );
|
|
s32 max_y_32 = round_f32_to_s32( max_y );
|
|
|
|
s32 buffer_width = buffer->width;
|
|
s32 buffer_height = buffer->height;
|
|
|
|
if ( min_x_32 < 0 )
|
|
min_x_32 = 0;
|
|
if ( min_y_32 < 0 )
|
|
min_y_32 = 0;
|
|
if ( max_x_32 > buffer_width )
|
|
max_x_32 = buffer_width;
|
|
if ( max_y_32 > buffer_height )
|
|
max_y_32 = buffer_height;
|
|
|
|
s32 red_32 = round_f32_to_s32( 255.f * red );
|
|
s32 green_32 = round_f32_to_s32( 255.f * green );
|
|
s32 blue_32 = round_f32_to_s32( 255.f * blue );
|
|
|
|
s32 color =
|
|
(scast(s32, red_32) << 16)
|
|
| (scast(s32, green_32) << 8)
|
|
| (scast(s32, blue_32) << 0);
|
|
|
|
// Start with the pixel on the top left corner of the rectangle
|
|
u8* row = rcast(u8*, buffer->memory )
|
|
+ min_x_32 * buffer->bytes_per_pixel
|
|
+ min_y_32 * buffer->pitch;
|
|
|
|
for ( s32 y = min_y_32; y < max_y_32; ++ y )
|
|
{
|
|
s32* pixel_32 = rcast(s32*, row);
|
|
|
|
for ( s32 x = min_x_32; x < max_x_32; ++ x )
|
|
{
|
|
*pixel_32 = color;
|
|
pixel_32++;
|
|
}
|
|
row += buffer->pitch;
|
|
}
|
|
}
|
|
|
|
Engine_API
|
|
void on_module_reload( Memory* memory, platform::ModuleAPI* platfom_api )
|
|
{
|
|
|
|
}
|
|
|
|
Engine_API
|
|
void startup( Memory* memory, platform::ModuleAPI* platform_api )
|
|
{
|
|
#if Build_Development
|
|
memory->active_snapshot_slot = 1;
|
|
memory->replay_mode = ReplayMode_Off;
|
|
memory->active_input_replay_file = {};
|
|
memory->engine_loop_active = false;
|
|
memory->game_loop_active = false;
|
|
#endif
|
|
|
|
#if 0
|
|
for ( s32 slot = 0; slot < memory->Num_Snapshot_Slots; ++ slot )
|
|
{
|
|
// TODO(Ed) : Specify default file paths for saving slots ?
|
|
}
|
|
#endif
|
|
|
|
EngineState* state = rcast( EngineState*, memory->persistent );
|
|
assert( sizeof(EngineState) <= memory->persistent_size );
|
|
|
|
state->auto_snapshot_interval = 60.f;
|
|
|
|
state->tone_volume = 1000;
|
|
|
|
state->x_offset = 0;
|
|
state->y_offset = 0;
|
|
|
|
state->sample_wave_switch = false;
|
|
state->wave_tone_hz = 60;
|
|
state->sample_wave_sine_time = 0.f;
|
|
|
|
state->renderer_paused = false;
|
|
state->game_memory.persistent_size = memory->persistent_size / 2;
|
|
state->game_memory.persistent = rcast(Byte*, memory->persistent) + state->game_memory.persistent_size;
|
|
state->game_memory.transient_size = memory->transient_size / 2;
|
|
state->game_memory.transient = rcast(Byte*, memory->transient) + state->game_memory.transient_size;
|
|
|
|
hh::GameState* game_state = rcast( hh::GameState*, state->game_memory.persistent );
|
|
assert( sizeof(hh::GameState) <= state->game_memory.persistent_size );
|
|
|
|
hh::PlayerState* player = & game_state->player_state;
|
|
player->position.tile_map_x = 0;
|
|
player->position.tile_map_y = 0;
|
|
player->position.tile_x = 3;
|
|
player->position.tile_y = 3;
|
|
player->position.x = 0.f;
|
|
player->position.y = 0.f;
|
|
|
|
player->mid_jump = false;
|
|
player->jump_time = 0.f;
|
|
}
|
|
|
|
Engine_API
|
|
void shutdown( Memory* memory, platform::ModuleAPI* platform_api )
|
|
{
|
|
}
|
|
|
|
inline
|
|
void cannonicalize_coord( World* world, s32 num_tiles, s32* tile_map_coord, s32* tile_coord, f32* pos_coord )
|
|
{
|
|
s32 new_tile_map_coord = *tile_map_coord;
|
|
f32 tile_size = scast(f32, world->tile_size_in_meters);
|
|
|
|
// TODO(Ed) : Need to use an alt method for reconnonicalizing because this can end up rounding back up to the tile.
|
|
// TODO(Ed) : Add bounds checking to prevent wrapping
|
|
s32 offset = floor_f32_to_s32( (* pos_coord) / tile_size );
|
|
s32 new_tile_coord = (* tile_coord) + offset;
|
|
f32 new_pos_coord = (* pos_coord) - scast(f32, offset) * tile_size;
|
|
|
|
assert( new_pos_coord >= 0.f );
|
|
assert( new_pos_coord < tile_size );
|
|
|
|
if ( new_tile_coord < 0 )
|
|
{
|
|
new_tile_coord += num_tiles;
|
|
-- new_tile_map_coord;
|
|
}
|
|
if ( new_tile_coord >= num_tiles )
|
|
{
|
|
new_tile_coord -= num_tiles;
|
|
++ new_tile_map_coord;
|
|
}
|
|
|
|
(* tile_map_coord) = new_tile_map_coord;
|
|
(* tile_coord) = new_tile_coord;
|
|
(* pos_coord) = new_pos_coord;
|
|
}
|
|
|
|
inline
|
|
CanonPosition recannonicalize_position( World* world, CanonPosition pos )
|
|
{
|
|
CanonPosition result = pos;
|
|
cannonicalize_coord( world, world->num_tiles_x, & result.tile_map_x, & result.tile_x, & result.x );
|
|
cannonicalize_coord( world, world->num_tiles_y, & result.tile_map_y, & result.tile_y, & result.y );
|
|
return result;
|
|
}
|
|
|
|
inline
|
|
u32 tilemap_tile_value( TileMap* tile_map, World* world, s32 x, s32 y )
|
|
{
|
|
assert( tile_map != nullptr );
|
|
assert( world != nullptr );
|
|
assert( x >= 0 && x < scast(s32, world->num_tiles_x) );
|
|
assert( y >= 0 && y < scast(s32, world->num_tiles_y) );
|
|
return tile_map->tiles[ (y * world->num_tiles_x) + x ];
|
|
}
|
|
|
|
inline
|
|
b32 tilemap_is_point_empty( TileMap* tile_map, World* world, s32 tile_x, s32 tile_y )
|
|
{
|
|
assert( tile_map != nullptr );
|
|
assert( world != nullptr );
|
|
|
|
// Assume space is occupied if there is bad data
|
|
if ( tile_map == nullptr )
|
|
return false;
|
|
|
|
b32 is_empty = false;
|
|
if ( tile_x >= 0 && tile_x < world->num_tiles_x
|
|
&& tile_y >= 0 && tile_y < world->num_tiles_y )
|
|
{
|
|
u32 tile_value = tilemap_tile_value( tile_map, world, tile_x, tile_y );
|
|
is_empty = tile_value == 0;
|
|
}
|
|
return is_empty;
|
|
}
|
|
|
|
inline
|
|
TileMap* world_get_tilemap( World* world, s32 tile_map_x, s32 tile_map_y )
|
|
{
|
|
assert( tile_map_x >= 0 && tile_map_x < world->tilemaps_num_x );
|
|
assert( tile_map_y >= 0 && tile_map_y < world->tilemaps_num_y );
|
|
return & world->tile_maps[ (tile_map_y * world->tilemaps_num_x) + tile_map_x ];
|
|
}
|
|
|
|
internal
|
|
b32 world_is_point_empty( World* world, CanonPosition position )
|
|
{
|
|
assert( world != nullptr );
|
|
|
|
b32 is_empty = false;
|
|
|
|
TileMap* tile_map = world_get_tilemap( world, position.tile_map_x, position.tile_map_y );
|
|
is_empty = tilemap_is_point_empty( tile_map, world, position.tile_x, position.tile_y );
|
|
|
|
return is_empty;
|
|
}
|
|
|
|
void draw_debug_point(OffscreenBuffer* back_buffer, World* world, CanonPosition pos, f32 red, f32 green, f32 blue)
|
|
{
|
|
draw_rectangle(back_buffer,
|
|
pos.x * world->tile_meters_to_pixels + world->tile_upper_left_x + scast(f32, pos.tile_x * world->tile_size_in_pixels),
|
|
pos.y * world->tile_meters_to_pixels + world->tile_upper_left_y + scast(f32, pos.tile_y * world->tile_size_in_pixels),
|
|
(pos.x + 0.1f) * world->tile_meters_to_pixels + world->tile_upper_left_x + scast(f32, pos.tile_x * world->tile_size_in_pixels),
|
|
(pos.y + 0.1f) * world->tile_meters_to_pixels + world->tile_upper_left_y + scast(f32, pos.tile_y * world->tile_size_in_pixels),
|
|
red, green, blue);
|
|
}
|
|
|
|
Engine_API
|
|
void update_and_render( f32 delta_time, InputState* input, OffscreenBuffer* back_buffer
|
|
, Memory* memory, platform::ModuleAPI* platform_api, ThreadContext* thread )
|
|
{
|
|
EngineState* state = rcast( EngineState*, memory->persistent );
|
|
assert( sizeof(EngineState) <= memory->persistent_size );
|
|
|
|
// Engine auto_snapshot
|
|
{
|
|
state->auto_snapshot_timer += delta_time;
|
|
if ( state->auto_snapshot_timer >= state->auto_snapshot_interval )
|
|
{
|
|
state->auto_snapshot_timer = 0.f;
|
|
|
|
s32 current_slot = memory->active_snapshot_slot;
|
|
memory->active_snapshot_slot = 0;
|
|
|
|
take_engine_snapshot( memory, platform_api );
|
|
memory->active_snapshot_slot = current_slot;
|
|
state->auto_snapshot_timer = 0.f;
|
|
}
|
|
}
|
|
|
|
ControllerState* controller = & input->controllers[0];
|
|
|
|
EngineActions engine_actions {};
|
|
hh::PlayerActions player_actions {};
|
|
|
|
input_poll_engine_actions( input, & engine_actions );
|
|
|
|
if ( engine_actions.load_auto_snapshot )
|
|
{
|
|
s32 current_slot = memory->active_snapshot_slot;
|
|
memory->active_snapshot_slot = 0;
|
|
load_engine_snapshot( memory, platform_api );
|
|
memory->active_snapshot_slot = current_slot;
|
|
}
|
|
|
|
#if Build_Development
|
|
// Ease of use: Allow user to press L key without shift if engine loop recording is active.
|
|
engine_actions.loop_mode_engine |= engine_actions.loop_mode_game && memory->engine_loop_active;
|
|
|
|
if ( engine_actions.loop_mode_engine && ! memory->game_loop_active )
|
|
{
|
|
process_loop_mode( & take_engine_snapshot, & load_engine_snapshot, memory, state, input, platform_api );
|
|
memory->engine_loop_active = memory->replay_mode > ReplayMode_Off;
|
|
}
|
|
|
|
// Input recording and playback for engine state
|
|
if ( memory->engine_loop_active )
|
|
{
|
|
if ( memory->replay_mode == ReplayMode_Record )
|
|
{
|
|
record_input( memory, input, platform_api );
|
|
}
|
|
if ( memory->replay_mode == ReplayMode_Playback )
|
|
{
|
|
play_input( & load_engine_snapshot, memory, input, platform_api );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Process Engine Actions
|
|
{
|
|
state->x_offset += 3 * engine_actions.move_right;
|
|
state->x_offset -= 3 * engine_actions.move_left;
|
|
state->y_offset += 3 * engine_actions.move_down;
|
|
state->y_offset -= 3 * engine_actions.move_up;
|
|
|
|
if ( engine_actions.raise_volume )
|
|
{
|
|
state->tone_volume += 10;
|
|
}
|
|
if ( engine_actions.lower_volume )
|
|
{
|
|
state->tone_volume -= 10;
|
|
if ( state->tone_volume <= 0 )
|
|
state->tone_volume = 0;
|
|
}
|
|
|
|
if ( engine_actions.raise_tone_hz )
|
|
{
|
|
state->wave_tone_hz += 1;
|
|
}
|
|
if ( engine_actions.lower_tone_hz )
|
|
{
|
|
state->wave_tone_hz -= 1;
|
|
if ( state->wave_tone_hz <= 0 )
|
|
state->wave_tone_hz = 1;
|
|
}
|
|
|
|
if ( engine_actions.toggle_wave_tone )
|
|
{
|
|
state->sample_wave_switch ^= true;
|
|
}
|
|
|
|
if ( engine_actions.loop_mode_game && ! memory->engine_loop_active )
|
|
{
|
|
process_loop_mode( & take_game_snapshot, & load_game_snapshot, memory, state, input, platform_api );
|
|
memory->game_loop_active = memory->replay_mode > ReplayMode_Off;
|
|
}
|
|
|
|
#if Build_Development
|
|
if ( engine_actions.pause_renderer )
|
|
{
|
|
if ( state->renderer_paused )
|
|
{
|
|
platform_api->debug_set_pause_rendering(false);
|
|
state->renderer_paused = false;
|
|
}
|
|
else
|
|
{
|
|
platform_api->debug_set_pause_rendering(true);
|
|
state->renderer_paused = true;
|
|
}
|
|
}
|
|
|
|
if ( ! memory->game_loop_active )
|
|
{
|
|
if ( engine_actions.set_snapshot_slot_1 ) memory->active_snapshot_slot = 1;
|
|
if ( engine_actions.set_snapshot_slot_2 ) memory->active_snapshot_slot = 2;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if Build_Development
|
|
if ( ! memory->engine_loop_active )
|
|
{
|
|
// Input recording and playback for game state
|
|
if ( memory->replay_mode == ReplayMode_Record )
|
|
{
|
|
record_input( memory, input, platform_api );
|
|
}
|
|
if ( memory->replay_mode == ReplayMode_Playback )
|
|
{
|
|
play_input( & load_game_snapshot, memory, input, platform_api );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
hh::GameState* game_state = rcast( hh::GameState*, state->game_memory.persistent );
|
|
hh::PlayerState* player = & game_state->player_state;
|
|
|
|
f32 x_offset_f = scast(f32, state->x_offset);
|
|
f32 y_offset_f = scast(f32, state->y_offset);
|
|
|
|
constexpr s32 tile_map_num_x = 16;
|
|
constexpr s32 tile_map_num_y = 9;
|
|
|
|
// tiles_XY
|
|
u32 tiles_00 [tile_map_num_y][tile_map_num_x] = {
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
|
|
};
|
|
u32 tiles_10 [tile_map_num_y][tile_map_num_x] = {
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
};
|
|
u32 tiles_01 [tile_map_num_y][tile_map_num_x] = {
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
};
|
|
u32 tiles_11 [tile_map_num_y][tile_map_num_x] = {
|
|
{ 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
};
|
|
|
|
TileMap tile_maps[2][2] {};
|
|
tile_maps[0][0].tiles = rcast(u32*, tiles_00);
|
|
tile_maps[0][1].tiles = rcast(u32*, tiles_10);
|
|
tile_maps[1][0].tiles = rcast(u32*, tiles_01);
|
|
tile_maps[1][1].tiles = rcast(u32*, tiles_11);
|
|
|
|
World world;
|
|
world.tile_size_in_meters = 1.4f;
|
|
world.tile_size_in_pixels = 85;
|
|
world.tile_meters_to_pixels = scast(f32, world.tile_size_in_pixels) / world.tile_size_in_meters;
|
|
|
|
f32 tile_size_in_pixels = scast(f32, world.tile_size_in_pixels);
|
|
|
|
world.num_tiles_x = tile_map_num_x;
|
|
world.num_tiles_y = tile_map_num_y;
|
|
|
|
f32 scale = 85;
|
|
|
|
world.tile_upper_left_x = -( tile_size_in_pixels * 0.5f);
|
|
world.tile_upper_left_y = -( tile_size_in_pixels * 0.25f);
|
|
|
|
world.tilemaps_num_x = 2;
|
|
world.tilemaps_num_y = 2;
|
|
|
|
world.tile_maps = rcast(TileMap*, tile_maps);
|
|
|
|
TileMap* current_tile_map = world_get_tilemap( & world, player->position.tile_map_x, player->position.tile_map_y );
|
|
assert( current_tile_map != nullptr );
|
|
|
|
player->height = 1.4f;
|
|
player->width = player->height * 0.7f;
|
|
|
|
f32 player_half_width = player->width / 2.f;
|
|
f32 player_quarter_height = player->height / 4.f;
|
|
|
|
input_poll_player_actions( input, & player_actions );
|
|
{
|
|
f32 move_speed = 6.f;
|
|
|
|
f32 new_player_pos_x = player->position.x;
|
|
f32 new_player_pos_y = player->position.y;
|
|
if ( player_actions.player_x_move_analog || player_actions.player_y_move_analog )
|
|
{
|
|
new_player_pos_x += scast(f32, player_actions.player_x_move_analog * delta_time * move_speed);
|
|
new_player_pos_y -= scast(f32, player_actions.player_y_move_analog * delta_time * move_speed);
|
|
}
|
|
else
|
|
{
|
|
new_player_pos_x += scast(f32, player_actions.player_x_move_digital) * delta_time * move_speed;
|
|
new_player_pos_y -= scast(f32, player_actions.player_y_move_digital) * delta_time * move_speed;
|
|
}
|
|
new_player_pos_y += sinf( player->jump_time * TAU ) * 10.f * delta_time;
|
|
|
|
b32 valid_new_pos = true;
|
|
{
|
|
//RawPosition test_pos = {
|
|
// new_player_pos_x - player_half_width, new_player_pos_y - player_quarter_height,
|
|
// player->position.tile_map_x, player->position.tile_map_y
|
|
//};
|
|
|
|
CanonPosition test_pos = {
|
|
new_player_pos_x, new_player_pos_y,
|
|
player->position.tile_map_x, player->position.tile_map_y,
|
|
player->position.tile_x, player->position.tile_y
|
|
};
|
|
test_pos = recannonicalize_position( & world, test_pos );
|
|
|
|
// TODO(Ed) : Need a delta-function that auto-reconnonicalizes.
|
|
|
|
CanonPosition test_pos_nw {
|
|
new_player_pos_x - player_half_width, new_player_pos_y - player_quarter_height,
|
|
player->position.tile_map_x, player->position.tile_map_y,
|
|
player->position.tile_x, player->position.tile_y
|
|
};
|
|
test_pos_nw = recannonicalize_position( & world, test_pos_nw );
|
|
valid_new_pos &= world_is_point_empty( & world, test_pos_nw );
|
|
|
|
CanonPosition test_pos_ne {
|
|
new_player_pos_x + player_half_width, new_player_pos_y - player_quarter_height,
|
|
player->position.tile_map_x, player->position.tile_map_y,
|
|
player->position.tile_x, player->position.tile_y
|
|
};
|
|
test_pos_ne = recannonicalize_position( & world, test_pos_ne );
|
|
valid_new_pos &= world_is_point_empty( & world, test_pos_ne );
|
|
|
|
CanonPosition test_pos_sw {
|
|
new_player_pos_x - player_half_width, new_player_pos_y,
|
|
player->position.tile_map_x, player->position.tile_map_y,
|
|
player->position.tile_x, player->position.tile_y
|
|
};
|
|
test_pos_sw = recannonicalize_position( & world, test_pos_sw );
|
|
valid_new_pos &= world_is_point_empty( & world, test_pos_sw );
|
|
|
|
CanonPosition test_pos_se {
|
|
new_player_pos_x + player_half_width, new_player_pos_y,
|
|
player->position.tile_map_x, player->position.tile_map_y,
|
|
player->position.tile_x, player->position.tile_y
|
|
};
|
|
test_pos_se = recannonicalize_position( & world, test_pos_se );
|
|
valid_new_pos &= world_is_point_empty( & world, test_pos_se );
|
|
}
|
|
|
|
if ( valid_new_pos )
|
|
{
|
|
CanonPosition new_pos = {
|
|
new_player_pos_x, new_player_pos_y,
|
|
player->position.tile_map_x, player->position.tile_map_y,
|
|
player->position.tile_x, player->position.tile_y
|
|
};
|
|
player->position = recannonicalize_position( & world, new_pos );
|
|
}
|
|
|
|
// player_tile_x
|
|
|
|
if ( player->jump_time > 0.f )
|
|
{
|
|
player->jump_time -= delta_time;
|
|
}
|
|
else
|
|
{
|
|
player->jump_time = 0.f;
|
|
player->mid_jump = false;
|
|
}
|
|
|
|
if ( ! player->mid_jump && player_actions.jump )
|
|
{
|
|
player->jump_time = 1.f;
|
|
player->mid_jump = true;
|
|
}
|
|
}
|
|
|
|
draw_rectangle( back_buffer
|
|
, 0.f, 0.f
|
|
, scast(f32, back_buffer->width), scast(f32, back_buffer->height)
|
|
, 1.f, 0.24f, 0.24f );
|
|
|
|
|
|
// Draw tilemap
|
|
for ( s32 row = 0; row < 9; ++ row )
|
|
{
|
|
for ( s32 col = 0; col < 16; ++ col )
|
|
{
|
|
u32 tileID = tilemap_tile_value( current_tile_map, & world, col, row );
|
|
f32 color[3] = { 0.15f, 0.15f, 0.15f };
|
|
|
|
if ( tileID == 1 )
|
|
{
|
|
color[0] = 0.22f;
|
|
color[1] = 0.22f;
|
|
color[2] = 0.22f;
|
|
}
|
|
|
|
if ( row == player->position.tile_y && col == player->position.tile_x )
|
|
{
|
|
color[0] = 0.44f;
|
|
color[1] = 0.3f;
|
|
color[2] = 0.3f;
|
|
}
|
|
|
|
f32 min_x = world.tile_upper_left_x + scast(f32, col) * tile_size_in_pixels;
|
|
f32 min_y = world.tile_upper_left_y + scast(f32, row) * tile_size_in_pixels;
|
|
// f32 min_x = scast(f32, col) * tile_size_in_pixels;
|
|
// f32 min_y = scast(f32, row) * tile_size_in_pixels;
|
|
f32 max_x = min_x + tile_size_in_pixels;
|
|
f32 max_y = min_y + tile_size_in_pixels;
|
|
|
|
draw_rectangle( back_buffer
|
|
, min_x, min_y
|
|
, max_x, max_y
|
|
, color[0], color[1], color[2] );
|
|
}
|
|
}
|
|
|
|
// Player
|
|
f32 player_red = 0.7f;
|
|
f32 player_green = 0.7f;
|
|
f32 player_blue = 0.3f;
|
|
|
|
f32 player_tile_x_offset = scast(f32, player->position.tile_x * world.tile_size_in_pixels);
|
|
f32 player_tile_y_offset = scast(f32, player->position.tile_y * world.tile_size_in_pixels);
|
|
|
|
f32 player_screen_pos_x = world.tile_upper_left_x + player_tile_x_offset + player->position.x * world.tile_meters_to_pixels;
|
|
f32 player_screen_pos_y = world.tile_upper_left_y + player_tile_y_offset + player->position.y * world.tile_meters_to_pixels;
|
|
|
|
draw_rectangle( back_buffer
|
|
, player_screen_pos_x - player_half_width * world.tile_meters_to_pixels, player_screen_pos_y - player->height * world.tile_meters_to_pixels
|
|
, player_screen_pos_x + player_half_width * world.tile_meters_to_pixels, player_screen_pos_y
|
|
, player_red, player_green, player_blue );
|
|
|
|
// Auto-Snapshot percent bar
|
|
if (1)
|
|
{
|
|
f32 snapshot_percent_x = ((state->auto_snapshot_timer / state->auto_snapshot_interval)) * (f32)back_buffer->width / 4.f;
|
|
draw_rectangle( back_buffer
|
|
, 0.f, 0.f
|
|
, snapshot_percent_x, 10.f
|
|
, 0.f, 0.15f, 0.35f );
|
|
}
|
|
|
|
#if Build_Development
|
|
if ( memory->replay_mode == ReplayMode_Record )
|
|
{
|
|
draw_rectangle( back_buffer
|
|
, player->position.x + 50.f, player->position.y - 50.f
|
|
, player->position.x + 10.f, player->position.y + 40.f
|
|
, 1.f, 1.f, 1.f );
|
|
}
|
|
#endif
|
|
|
|
// Change above to use draw rectangle
|
|
if ( 0 )
|
|
{
|
|
draw_rectangle( back_buffer
|
|
, (f32)input->controllers[0].mouse->X.end, (f32)input->controllers[0].mouse->Y.end
|
|
, (f32)input->controllers[0].mouse->X.end + 10.f, (f32)input->controllers[0].mouse->Y.end + 10.f
|
|
, 1.f, 1.f, 0.f );
|
|
}
|
|
|
|
// Mouse buttons test
|
|
#if 0
|
|
{
|
|
if ( input->controllers[0].mouse->left.ended_down == true )
|
|
render_player( back_buffer, 5, 5 );
|
|
|
|
if ( input->controllers[0].mouse->middle.ended_down == true )
|
|
|
|
render_player( back_buffer, 5, 20 );
|
|
|
|
if ( input->controllers[0].mouse->right.ended_down == true )
|
|
render_player( back_buffer, 5, 35 );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
Engine_API
|
|
void update_audio( f32 delta_time, AudioBuffer* audio_buffer, Memory* memory, platform::ModuleAPI* platform_api, ThreadContext* thread )
|
|
{
|
|
EngineState* state = rcast( EngineState*, memory->persistent );
|
|
do_once_start
|
|
|
|
do_once_end
|
|
|
|
// TODO(Ed) : Allow sample offsets here for more robust platform options
|
|
if ( ! state->sample_wave_switch )
|
|
output_sound( state, audio_buffer, sine_wave_sample_value );
|
|
else
|
|
output_sound( state, audio_buffer, square_wave_sample_value );
|
|
}
|
|
|
|
NS_ENGINE_END
|
|
|
|
#undef pressed
|