struct game_memory {
    float player_x;
    float player_y;
}

struct transient_memory {
    vertex vertices[1000];
    int vertices_count;
}

struct entity_chunk {
    entity entities[1000];
    entity_chunk* next;
}

|-----------------------------------| <- Memory we get from the win32 layer.
|game_state|other things------------| <- we want to treat it like this.
game_state* state = (game_state*) memory; // memory is void*. This is not the actual code from handmade hero. 

// Those next two lines are the values you would use to create a memory arena for the rest of the memory.
void* rest_of_the_memory = memory + sizeof( game_state );
u64 rest_of_the_memory_size = memory_size - sizeof( game_state );

|game_state|------------------------| push(...)
|game_state|x|----------------------| push(...)
|game_state|x|x|--------------------| BeginTemporary(...)
|game_state|x|x|--------------------| push(...)
|game_state|x|x|y|------------------| push(...)
|game_state|x|x|y|y|----------------| EndTemporary(...)
|game_state|x|x|--------------------| push(...)
|game_state|x|x|x|------------------| 

|game_state|x|x|--------------------| createSubArena(...)
|game_state|x|x|------|-------------| push(sub, ...)
|game_state|x|x|y|----|-------------| push(sub, ...)
|game_state|x|x|y|y|--|-------------| push(main, ...)
|game_state|x|x|y|y|--|x|-----------|

p_to_the_rest = pointer_to_the_beginning + sizeof(game_state);

static void* allocate(int size, void* start){
    
    // check that it doesn't overflow
    assert((game_state->last_pointer + size) <= game_state->memory_size);

    // I would dereference the pointer to write to it, right?
    *game_state->last_pointer = *start;

    // update the position of the last_pointer
    game_state->last_pointer += size;
    
    // return pointer to the newly allocated data
    return game_state->last_pointer - size;
}

static void push_vertex(Vertex vertex){
    vertices[last_vertex_index++] = vertex;
}
static void render(){
   glBufferData(...push all the vertices to GPU...);
   //            mode       first      count
   glDrawArrays(GL_TRIANGLES, 0, last_vertex_index);
}

foreach(object in draw_queue){
glBindVertexArray(object.vao);
glUniformMatrix4fv(modelMatrix, 1, false, &object.modelMatrix);
glDrawArrays(GL_TRIANGLES, 0, object .last_vertex_index);
}

static void* allocate(int size, void* start){
    
    // Here you compare a pointer and a size.
    // You need to either compare 2 pointers or 2 size.
    // - replace game_state->memory_size with game_state->last_memory_address
    // - or replace game_state->last_pointer with game_state->used_memory;
    assert((game_state->last_pointer + size) <= game_state->memory_size);

    // You don't want to de-reference pointers here.
    // If you de-reference them you modify the content (what the address is pointing to).
    // Here we want to modify or store the address of the content.
    *game_state->last_pointer = *start;

    // You didn't de-reference here which is good.
    game_state->last_pointer += size;
    
    // return pointer to the newly allocated data
    return game_state->last_pointer - size;
}

// Here is your function "fixed"

typedef struct GameState {
    ...
    void* last_pointer;
    void* last_memory_address;
    ...
} GameState;

...
game_state->last_pointer = memory + sizeof( GameState );
game_state->last_memory_address = game_state->last_pointer + ( memory_size - sizeof( GameState ) );
...

void* allocate( int size ) {
    void* result;
    assert( game_state->last_pointer + size <= game_state->last_memory_address );
    result = game_state->last_pointer;
    game_state->last_pointer += size;
    return result;
}

// But this seems less intuitive to me than what Casey is doing in handmade hero.
// Memory arena.
typedef struct Data {
    void* base; // The first address of "user" memory. It never changes.
    size_t reserved; // The amount of "user" memory. It never changes.
    size_t used; // The amount of "user" memory used.
} Data;

...
data->base = memory + sizeof( GameState );
data->reserved = memory_size - sizeof( GameState );
data->used = 0;
...

void* allocate( Data* memory, size_t size ) {

    void* result = 0;
    assert( memory->used + size <= memory->reserved );

    if ( memory->used + size <= memory->reserved ) {
        result = memory->base + memory->used;
        memory->used += size;
    }

    return result;
}

#define HANDMADE_MATH_IMPLEMENTATION
#include "HandmadeMath.h"