368 lines
8.8 KiB
C
368 lines
8.8 KiB
C
/*
|
|
* Mr. 4th Dimention - Allen Webster
|
|
*
|
|
* 12.12.2014
|
|
*
|
|
* Application Layer for project codename "4ed"
|
|
*
|
|
*/
|
|
|
|
#ifndef FRED_H
|
|
#define FRED_H
|
|
|
|
struct Partition{
|
|
u8 *base;
|
|
i32 pos, max;
|
|
};
|
|
|
|
inline Partition
|
|
partition_open(void *memory, i32 size){
|
|
Partition partition;
|
|
partition.base = (u8*)memory;;
|
|
partition.pos = 0;
|
|
partition.max = size;
|
|
return partition;
|
|
}
|
|
|
|
inline void*
|
|
partition_allocate(Partition *data, i32 size){
|
|
void *ret = 0;
|
|
if (size > 0 && data->pos + size <= data->max){
|
|
ret = data->base + data->pos;
|
|
data->pos += size;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
inline void
|
|
partition_align(Partition *data, u32 boundary){
|
|
data->pos = (data->pos + (boundary - 1)) & (~boundary);
|
|
}
|
|
|
|
inline void*
|
|
partition_current(Partition *data){
|
|
return data->base + data->pos;
|
|
}
|
|
|
|
inline i32
|
|
partition_remaining(Partition *data){
|
|
return data->max - data->pos;
|
|
}
|
|
|
|
inline Partition
|
|
partition_sub_part(Partition *data, i32 size){
|
|
Partition result = {};
|
|
void *d = partition_allocate(data, size);
|
|
if (d) result = partition_open(d, size);
|
|
return result;
|
|
}
|
|
|
|
#define push_struct(part, T) (T*)partition_allocate(part, sizeof(T))
|
|
#define push_array(part, T, size) (T*)partition_allocate(part, sizeof(T)*(size))
|
|
#define push_block(part, size) partition_allocate(part, size)
|
|
|
|
enum Memory_Bubble_Flag{
|
|
MEM_BUBBLE_USED = 0x1,
|
|
MEM_BUBBLE_DEBUG = 0xD3000000,
|
|
MEM_BUBBLE_SYS_DEBUG = 0x5D000000,
|
|
MEM_BUBBLE_DEBUG_MASK = 0xFF000000
|
|
};
|
|
struct Bubble{
|
|
Bubble *prev;
|
|
Bubble *next;
|
|
u32 flags;
|
|
i32 size;
|
|
u32 type;
|
|
u32 _unused_;
|
|
};
|
|
struct General_Memory{
|
|
Bubble sentinel;
|
|
};
|
|
|
|
inline void
|
|
insert_bubble(Bubble *prev, Bubble *bubble){
|
|
bubble->prev = prev;
|
|
bubble->next = prev->next;
|
|
bubble->prev->next = bubble;
|
|
bubble->next->prev = bubble;
|
|
}
|
|
|
|
inline void
|
|
remove_bubble(Bubble *bubble){
|
|
bubble->prev->next = bubble->next;
|
|
bubble->next->prev = bubble->prev;
|
|
}
|
|
|
|
#if FRED_INTERNAL
|
|
#define MEM_BUBBLE_FLAG_INIT MEM_BUBBLE_DEBUG
|
|
#else
|
|
#define MEM_BUBBLE_FLAG_INIT 0
|
|
#endif
|
|
|
|
internal void
|
|
general_memory_open(General_Memory *general, void *memory, i32 size){
|
|
general->sentinel.prev = &general->sentinel;
|
|
general->sentinel.next = &general->sentinel;
|
|
general->sentinel.flags = MEM_BUBBLE_USED;
|
|
general->sentinel.size = 0;
|
|
|
|
Bubble *first = (Bubble*)memory;
|
|
first->flags = (u32)MEM_BUBBLE_FLAG_INIT;
|
|
first->size = size - sizeof(Bubble);
|
|
insert_bubble(&general->sentinel, first);
|
|
}
|
|
|
|
#define BUBBLE_MIN_SIZE 1024
|
|
|
|
internal void
|
|
general_memory_attempt_split(Bubble *bubble, i32 wanted_size){
|
|
i32 remaining_size = bubble->size - wanted_size;
|
|
if (remaining_size >= BUBBLE_MIN_SIZE){
|
|
bubble->size = wanted_size;
|
|
Bubble *new_bubble = (Bubble*)((u8*)(bubble + 1) + wanted_size);
|
|
new_bubble->flags = (u32)MEM_BUBBLE_FLAG_INIT;
|
|
new_bubble->size = remaining_size - sizeof(Bubble);
|
|
insert_bubble(bubble, new_bubble);
|
|
}
|
|
}
|
|
|
|
internal void*
|
|
general_memory_allocate(General_Memory *general, i32 size, u32 type = 0){
|
|
void *result = 0;
|
|
if (size < Kbytes(1)){
|
|
int x = 1; AllowLocal(x);
|
|
}
|
|
for (Bubble *bubble = general->sentinel.next;
|
|
bubble != &general->sentinel;
|
|
bubble = bubble->next){
|
|
if (!(bubble->flags & MEM_BUBBLE_USED)){
|
|
if (bubble->size >= size){
|
|
result = bubble + 1;
|
|
bubble->flags |= MEM_BUBBLE_USED;
|
|
bubble->type = type;
|
|
general_memory_attempt_split(bubble, size);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
inline void
|
|
general_memory_do_merge(Bubble *left, Bubble *right){
|
|
left->size += sizeof(Bubble) + right->size;
|
|
remove_bubble(right);
|
|
}
|
|
|
|
inline void
|
|
general_memory_attempt_merge(Bubble *left, Bubble *right){
|
|
if (!(left->flags & MEM_BUBBLE_USED) &&
|
|
!(right->flags & MEM_BUBBLE_USED)){
|
|
general_memory_do_merge(left, right);
|
|
}
|
|
}
|
|
|
|
internal void
|
|
general_memory_free(General_Memory *general, void *memory){
|
|
Bubble *bubble = ((Bubble*)memory) - 1;
|
|
Assert((!FRED_INTERNAL) || (bubble->flags & MEM_BUBBLE_DEBUG_MASK) == MEM_BUBBLE_DEBUG);
|
|
bubble->flags &= ~MEM_BUBBLE_USED;
|
|
bubble->type = 0;
|
|
Bubble *prev, *next;
|
|
prev = bubble->prev;
|
|
next = bubble->next;
|
|
general_memory_attempt_merge(bubble, next);
|
|
general_memory_attempt_merge(prev, bubble);
|
|
}
|
|
|
|
internal void*
|
|
general_memory_reallocate(General_Memory *general, void *old, i32 old_size, i32 size, u32 type = 0){
|
|
void *result = old;
|
|
Bubble *bubble = ((Bubble*)old) - 1;
|
|
bubble->type = type;
|
|
Assert((!FRED_INTERNAL) || (bubble->flags & MEM_BUBBLE_DEBUG_MASK) == MEM_BUBBLE_DEBUG);
|
|
i32 additional_space = size - bubble->size;
|
|
if (additional_space > 0){
|
|
Bubble *next = bubble->next;
|
|
if (!(next->flags & MEM_BUBBLE_USED) &&
|
|
next->size + sizeof(Bubble) >= additional_space){
|
|
general_memory_do_merge(bubble, next);
|
|
general_memory_attempt_split(bubble, size);
|
|
}
|
|
else{
|
|
result = general_memory_allocate(general, size, type);
|
|
if (old_size) memcpy(result, old, old_size);
|
|
general_memory_free(general, old);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
inline void*
|
|
general_memory_reallocate_nocopy(General_Memory *general, void *old, i32 size, u32 type = 0){
|
|
return general_memory_reallocate(general, old, 0, size, type);
|
|
}
|
|
|
|
struct Temp_Memory{
|
|
Partition *part;
|
|
i32 pos;
|
|
};
|
|
|
|
internal Temp_Memory
|
|
begin_temp_memory(Partition *data){
|
|
Temp_Memory result;
|
|
result.part = data;
|
|
result.pos = data->pos;
|
|
return result;
|
|
}
|
|
|
|
internal void
|
|
end_temp_memory(Temp_Memory temp){
|
|
temp.part->pos = temp.pos;
|
|
}
|
|
|
|
struct Mem_Options{
|
|
Partition part;
|
|
General_Memory general;
|
|
};
|
|
|
|
#if SOFTWARE_RENDER
|
|
struct Render_Target{
|
|
void *pixel_data;
|
|
i32 width, height, pitch;
|
|
};
|
|
#else
|
|
struct Render_Target{
|
|
void *handle;
|
|
void *context;
|
|
i32_Rect clip_boxes[5];
|
|
i32 clip_top;
|
|
i32 width, height;
|
|
i32 bound_texture;
|
|
u32 color;
|
|
};
|
|
#endif
|
|
|
|
struct Application_Memory{
|
|
void *vars_memory;
|
|
i32 vars_memory_size;
|
|
void *target_memory;
|
|
i32 target_memory_size;
|
|
};
|
|
|
|
#define KEY_INPUT_BUFFER_SIZE 4
|
|
#define KEY_INPUT_BUFFER_DSIZE (KEY_INPUT_BUFFER_SIZE << 1)
|
|
|
|
enum Key_Control{
|
|
CONTROL_KEY_SHIFT,
|
|
CONTROL_KEY_CONTROL,
|
|
CONTROL_KEY_ALT,
|
|
// always last
|
|
CONTROL_KEY_COUNT
|
|
};
|
|
|
|
struct Key_Event_Data{
|
|
u16 keycode;
|
|
u16 loose_keycode;
|
|
u16 character;
|
|
u16 character_no_caps_lock;
|
|
};
|
|
|
|
struct Key_Input_Data{
|
|
// NOTE(allen): keycodes here
|
|
Key_Event_Data press[KEY_INPUT_BUFFER_SIZE];
|
|
Key_Event_Data hold[KEY_INPUT_BUFFER_SIZE];
|
|
i32 press_count;
|
|
i32 hold_count;
|
|
|
|
// NOTE(allen):
|
|
// true when the key is held down
|
|
// false when the key is not held down
|
|
bool8 control_keys[CONTROL_KEY_COUNT];
|
|
bool8 caps_lock;
|
|
};
|
|
|
|
struct Key_Summary{
|
|
i32 count;
|
|
Key_Event_Data keys[KEY_INPUT_BUFFER_DSIZE];
|
|
bool8 modifiers[CONTROL_KEY_COUNT];
|
|
};
|
|
|
|
struct Key_Single{
|
|
Key_Event_Data key;
|
|
bool8 *modifiers;
|
|
};
|
|
|
|
inline Key_Single
|
|
get_single_key(Key_Summary *summary, i32 index){
|
|
Assert(index >= 0 && index < summary->count);
|
|
Key_Single key;
|
|
key.key = summary->keys[index];
|
|
key.modifiers = summary->modifiers;
|
|
return key;
|
|
}
|
|
|
|
struct Mouse_State{
|
|
bool32 out_of_window;
|
|
bool32 left_button, right_button;
|
|
bool32 left_button_prev, right_button_prev;
|
|
i32 x, y;
|
|
i16 wheel;
|
|
};
|
|
|
|
struct Mouse_Summary{
|
|
i32 mx, my;
|
|
bool32 l, r;
|
|
bool32 press_l, press_r;
|
|
bool32 release_l, release_r;
|
|
bool32 out_of_window;
|
|
bool32 wheel_used;
|
|
i16 wheel_amount;
|
|
};
|
|
|
|
struct Input_Summary{
|
|
Mouse_Summary mouse;
|
|
Key_Summary keys;
|
|
Key_Codes *codes;
|
|
};
|
|
|
|
// TODO(allen): This can go, and we can just use a String for it.
|
|
struct Clipboard_Contents{
|
|
u8 *str;
|
|
i32 size;
|
|
};
|
|
|
|
struct Thread_Context;
|
|
|
|
internal bool32
|
|
app_init(Thread_Context *thread,
|
|
Application_Memory *memory,
|
|
Key_Codes *lose_codes,
|
|
Clipboard_Contents clipboard);
|
|
|
|
enum Application_Mouse_Cursor{
|
|
APP_MOUSE_CURSOR_DEFAULT,
|
|
APP_MOUSE_CURSOR_ARROW,
|
|
APP_MOUSE_CURSOR_IBEAM,
|
|
APP_MOUSE_CURSOR_LEFTRIGHT,
|
|
APP_MOUSE_CURSOR_UPDOWN,
|
|
// never below this
|
|
APP_MOUSE_CURSOR_COUNT
|
|
};
|
|
|
|
struct Application_Step_Result{
|
|
Application_Mouse_Cursor mouse_cursor_type;
|
|
bool32 redraw;
|
|
};
|
|
|
|
internal Application_Step_Result
|
|
app_step(Thread_Context *thread,
|
|
Key_Codes *codes,
|
|
Key_Input_Data *input, Mouse_State *state,
|
|
bool32 time_step, Render_Target *target,
|
|
Application_Memory *memory,
|
|
Clipboard_Contents clipboard,
|
|
bool32 first_step, bool32 force_redraw);
|
|
|
|
#endif
|