// ---------------------------------------------------------------------------
eir_gfx_sprite_batch_t * eir_gfx_push_sprite_batch_to_group(
eir_gfx_group_t * group,
const eir_gfx_texture_t * texture,
size_t sprite_count,
bool editable,
bool use_screen_coord,
bool visible
)
{
eir_gfx_sprite_batch_t * batch = 0;
if (group && sprite_count > 0)
{
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(group->sprite_batches, batch);
}
if (batch)
{
EIR_KER_ALLOC_SORTABLE_ARRAY(eir_gfx_sprite_t, batch->sprites, sprite_count, eir_gfx_init_sprite);
batch->texture = texture;
batch->info = eir_gfx_item_flag_default;
if (editable)
{
batch->info |= eir_gfx_item_flag_editable;
}
if (visible)
{
batch->info |= eir_gfx_item_flag_visible;
}
if (use_screen_coord)
{
batch->info |= eir_gfx_item_flag_use_screen_coord;
}
}
return batch;
}
// ---------------------------------------------------------------------------
eir_gfx_image_t * eir_gfx_load_image(
eir_gfx_env_t * env,
const char * img_filename,
bool must_invert_img
)
{
eir_gfx_image_t * image = 0;
if (env)
{
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(env->images, image);
}
if (image)
{
bool result = eir_gfx_api_load_image(
img_filename,
must_invert_img,
image
);
if (!result)
{
EIR_KER_LOG_ERROR("CANNOT LOAD IMAGE FROM FILE %s", img_filename);
eir_gfx_release_image(image);
image = 0;
}
}
return image;
}
eir_snd_sound_t * eir_snd_load_sound_file(eir_snd_env_t * snd_env, const char * filename)
{
eir_snd_sound_t * sound = 0;
if (snd_env)
{
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(snd_env->sounds, sound);
}
if (sound)
{
sound->chunk = eir_snd_api_create_chunk_from_file(filename);
}
return sound;
}
// ---------------------------------------------------------------------------
eir_gfx_texture_t * eir_gfx_create_texture(
eir_gfx_env_t * env,
const eir_gfx_image_t * image
)
{
eir_gfx_texture_t * texture = 0;
if (env && image)
{
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(env->textures, texture);
}
if (texture)
{
texture->id = eir_gfx_api_create_texture(image);
texture->image = image;
if (texture->id == EIR_GFX_INVALID_TEXTURE_HANDLE)
{
EIR_KER_LOG_ERROR("CANNOT CREATE TEXTURE FROM IMAGE");
eir_gfx_release_texture(texture);
}
}
return texture;
}
// ---------------------------------------------------------------------------
eir_gfx_rect_batch_t * eir_gfx_push_rect_batch_to_group(
eir_gfx_group_t * group,
size_t rect_count,
bool editable,
bool use_screen_coord,
bool visible
)
{
eir_gfx_rect_batch_t * batch = 0;
if (group && rect_count > 0)
{
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(group->rect_batches, batch);
}
if (batch)
{
EIR_KER_ALLOC_SORTABLE_ARRAY(eir_gfx_rect_t, batch->rects, rect_count, eir_gfx_init_rect);
batch->info = eir_gfx_item_flag_default;
if (editable)
{
batch->info |= eir_gfx_item_flag_editable;
}
if (visible)
{
batch->info |= eir_gfx_item_flag_visible;
}
if (use_screen_coord)
{
batch->info |= eir_gfx_item_flag_use_screen_coord;
}
}
else
{
EIR_KER_LOG_ERROR("CANNOT PUSH MORE RECT BATCH TO GROUP");
}
return batch;
}
eir_gme_world_t * eir_gme_create_world(
eir_gme_env_t * env,
size_t max_entity_count
)
{
eir_gme_world_t * world = 0;
if (env)
{
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(env->worlds, world);
}
if (world)
{
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_entity_flags_t,
world->entities_flags,
max_entity_count,
eir_gme_init_entity_flags
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_position_component_t,
world->positions,
max_entity_count,
eir_gme_init_position
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_size_component_t,
world->sizes,
max_entity_count,
eir_gme_init_size
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_sprite_component_t,
world->sprites,
max_entity_count,
eir_gme_init_sprite
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_color_component_t,
world->colors,
max_entity_count,
eir_gme_init_color
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_motion_param_component_t,
world->motion_params,
max_entity_count,
eir_gme_init_motion_param
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_aabb_component_t,
world->aabbs,
max_entity_count,
eir_gme_init_aabb
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_physic_component_t,
world->physics,
max_entity_count,
eir_gme_init_physic
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_direction_component_t,
world->directions,
max_entity_count,
eir_gme_init_direction
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_state_component_t,
world->states,
max_entity_count,
eir_gme_init_state
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_fsm_component_t,
world->fsms,
max_entity_count,
eir_gme_init_fsm
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_aabb_primitive_component_t,
world->aabb_primitives,
max_entity_count,
eir_gme_init_aabb_primitive
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_keyboard_component_t,
world->keyboards,
max_entity_count,
eir_gme_init_keyboard
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_pad_component_t,
world->pads,
max_entity_count,
eir_gme_init_pad
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_map_component_t,
world->maps,
max_entity_count,
eir_gme_init_map
);
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_map_layer_link_component_t,
world->map_layer_links,
max_entity_count,
eir_gme_init_map_layer_link
);
alloc_colliding_map_tile_array_array(
&world->colliding_map_tile_array_array,
max_entity_count
);
}
return world;
}
void eir_gme_set_entity_map_tile(
eir_gme_world_t * world,
eir_gme_entity_t entity,
int layer_index,
int col_index,
int row_index,
eir_mth_vec2_t * uv_offset,
eir_mth_vec2_t * uv_size,
bool navigable
)
{
eir_gme_entity_flags_t * entity_flags = 0;
eir_gme_map_component_t * map_component = 0;
if (world)
{
EIR_KER_GET_ARRAY_ITEM(world->entities_flags, entity, entity_flags);
EIR_KER_GET_ARRAY_ITEM(world->maps, entity, map_component);
}
eir_gme_map_layer_t * map_layer = 0;
if (
entity_flags
&& (*entity_flags) & eir_gme_component_type_map
&& map_component
)
{
EIR_KER_GET_ARRAY_ITEM(map_component->layers, layer_index, map_layer);
}
eir_gme_map_tile_t * map_tile = 0;
if (
map_layer
&& col_index >= 0 && col_index < map_layer->col_count
&& row_index >= 0 && row_index < map_layer->row_count
)
{
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(map_layer->tiles, map_tile);
if (map_tile)
{
map_tile->col_index = col_index;
map_tile->row_index = row_index;
map_tile->navigable = navigable;
eir_mth_vec2_t position;
eir_mth_vec2_t size;
eir_gfx_color_t color;
position.x = map_layer->position.x + col_index * size.x;
position.y = map_layer->position.y + row_index * size.y;
size.x = map_layer->tile_width;
size.y = map_layer->tile_height;
color.r = 1.0f;
color.g = 1.0f;
color.b = 1.0f;
color.a = 1.0f;
map_tile->sprite_proxy = eir_gfx_add_sprite_to_batch(
map_layer->batch,
&position,
&size,
uv_offset,
uv_size,
&color,
true
);
}
else
{
EIR_KER_LOG_ERROR("NO MAP TILE AVAILABLE");
}
}
}
void eir_gme_set_entity_map_layer(
eir_gme_world_t * world,
eir_gme_entity_t entity,
eir_gfx_group_t * group,
eir_gfx_sprite_batch_t * batch,
const eir_mth_vec2_t * position,
int col_count,
int row_count,
int tile_width,
int tile_height,
size_t tiles_capacity
)
{
eir_gme_entity_flags_t * entity_flags = 0;
eir_gme_map_component_t * map_component = 0;
if (world && batch && group)
{
EIR_KER_GET_ARRAY_ITEM(world->entities_flags, entity, entity_flags);
EIR_KER_GET_ARRAY_ITEM(world->maps, entity, map_component);
}
if (
entity_flags
&& (*entity_flags) & eir_gme_component_type_map
&& map_component
)
{
eir_gme_map_layer_t * map_layer = 0;
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(
map_component->layers,
map_layer
);
if (map_layer)
{
if (position)
{
map_layer->position.x = position->x;
map_layer->position.y = position->y;
}
map_layer->col_count = col_count;
map_layer->row_count = row_count;
map_layer->tile_width = tile_width;
map_layer->tile_height = tile_height;
map_layer->group = group;
map_layer->batch = batch;
EIR_KER_ALLOCATE_ARRAY_BIS(
eir_gme_map_tile_t,
map_layer->tiles,
tiles_capacity,
eir_gme_init_map_tile
);
}
else
{
EIR_KER_LOG_ERROR("NO AVAILABLE MAP LAYER");
}
}
else
{
EIR_KER_LOG_ERROR("cannot find entity %d or component in array", entity);
}
}
// ---------------------------------------------------------------------------
eir_gfx_text_t * eir_gfx_push_text_to_group(
eir_gfx_group_t * group,
const char * text,
size_t max_text_length,
const eir_mth_vec2_t * position,
float font_size,
const eir_gfx_color_t * color,
bool editable,
bool use_screen_coord,
bool visible
)
{
eir_gfx_text_t * gfx_text = 0;
if (group && text && position && color)
{
EIR_KER_GET_ARRAY_NEXT_EMPTY_SLOT(group->texts, gfx_text)
}
if (gfx_text)
{
const float MAX_TEXTURE_WIDTH = 320;
const float MAX_TEXTURE_HEIGHT = 320;
const float MAX_TEXTURE_COL = 16;
const float MAX_TEXTURE_ROW = 16;
int text_len = strlen(text);
EIR_KER_ALLOC_SORTABLE_ARRAY(eir_gfx_sprite_t, gfx_text->sprites, max_text_length, eir_gfx_init_sprite);
eir_mth_vec2_t uv_offset;
eir_mth_vec2_t uv_size;
eir_mth_vec2_t size;
char c;
float x_offset;
float y_offset;
size.x = 0.9f < font_size ?
font_size : (MAX_TEXTURE_WIDTH / MAX_TEXTURE_COL) / 4.0f;
size.y = 0.9f < font_size ?
font_size : (MAX_TEXTURE_HEIGHT / MAX_TEXTURE_ROW) / 4.0f;
for (int index = 0; index < text_len; ++index)
{
float x = position->x + size.x * index;
float y = position->y;
uv_size.x = MAX_TEXTURE_WIDTH / MAX_TEXTURE_COL;
uv_size.y = MAX_TEXTURE_HEIGHT / MAX_TEXTURE_ROW;
c = text[index];
x_offset = (int)c % (int)MAX_TEXTURE_COL;
y_offset = (int)c / (int)MAX_TEXTURE_ROW;
uv_offset.x = x_offset * (MAX_TEXTURE_WIDTH / MAX_TEXTURE_COL);
uv_offset.y = y_offset * (MAX_TEXTURE_HEIGHT / MAX_TEXTURE_ROW);
eir_gfx_sprite_t * sprite = 0;
eir_gfx_sprite_handle_t * sprite_handle = 0;
EIR_KER_RESERVE_SORTABLE_ARRAY_NEXT_EMPTY_SLOT(
gfx_text->sprites,
sprite_handle,
eir_gfx_swap_sprite
);
if (sprite_handle && sprite_handle->ptr)
{
sprite = sprite_handle->ptr;
sprite->position.x = x;
sprite->position.y = y;
sprite->size.x = size.x;
sprite->size.y = size.y;
sprite->uv_offset.x = uv_offset.x;
sprite->uv_offset.y = uv_offset.y;
sprite->uv_size.x = uv_size.x;
sprite->uv_size.y = uv_size.y;
sprite->color.r = color->r;
sprite->color.g = color->g;
sprite->color.b = color->b;
sprite->color.a = color->a;
sprite->batch = gfx_text;
}
}
gfx_text->info |= eir_gfx_item_flag_modified;
if (editable)
{
gfx_text->info |= eir_gfx_item_flag_editable;
}
if (visible)
{
gfx_text->info |= eir_gfx_item_flag_visible;
}
if (use_screen_coord)
{
gfx_text->info |= eir_gfx_item_flag_use_screen_coord;
}
}
return gfx_text;
}
