void eol_component_list_new(eolComponent *component)
{
eolComponentList *listData;
if (component->componentData != NULL)
{
eol_logger_message(
EOL_LOG_WARN,
"eol_component:tried to make a list out of an existing component\n");
return;
}
component->componentData = malloc(sizeof(eolComponentList));
if (component->componentData == NULL)
{
eol_logger_message(
EOL_LOG_ERROR,
"eol_actor: failed to allocate data for new list\n");
return;
}
/*default values*/
memset(component->componentData,0,sizeof(eolComponentList));
listData = (eolComponentList *)component->componentData;
listData->backgroundAlpha = 1;
eol_vec3d_set(listData->backgroundColor,0.1,0.1,0.1);
listData->allowSelection = eolTrue;
listData->showBackground = eolTrue;
listData->showBoarder = eolTrue;
listData->fontSize = 2;
eol_vec3d_set(listData->highlightColor,0.2,1,1);
eol_vec3d_set(listData->textColor,1,1,1);
listData->alpha = 1;
component->type = eolListComponent;
}
void eol_level_save(char *filename,eolLevel *level)
{
eolConfig *fileData;
eolKeychain *fileKey;
if ((!level)||(!filename)||(strlen(filename)==0))
{
eol_logger_message(EOL_LOG_ERROR,"eol_level_save: Passed an empty parameter.");
return;
}
fileData = eol_config_new();
if (!fileData)
{
eol_logger_message(EOL_LOG_ERROR,"eol_level_save: failed to allocate new config data");
return;
}
eol_line_cpy(fileData->filename,filename);
fileKey = eol_keychain_new_hash();
if (fileKey)
{
fileData->_node = fileKey;
if (eol_level_build_save_keychain(level,fileKey))
{
/*now save the config to disk*/
eol_config_save_binary(fileData,filename);
}
}
eol_config_free(&fileData);
}
void editor_tile_workspace_sync(eolWindow *win)
{
int i;
editorTileData *tileData;
eolTileType *tileType;
eolComponent *list;
EditorWorkspace *workspace = NULL;
if (!win)
{
eol_logger_message(EOL_LOG_ERROR,"tile panel has no window!");
return;
}
tileData = editor_tile_get_data(win);
if (!tileData)
{
eol_logger_message(EOL_LOG_ERROR,"tile panel has no data!");
return;
}
editor_orientation_update_callback(
tileData->orientationWindow,
NULL,
NULL,
NULL);
workspace = editor_get_workspace(tileData->workspace);
if (!workspace)
{
eol_logger_message(EOL_LOG_ERROR,"No Workspace to sync to!");
return;
}
list = eol_window_get_component_by_name(win,"tile_type_list");
if (!list)
{
eol_logger_message(EOL_LOG_ERROR,"missing tile type list component!");
return;
}
editor_workspace_show_mouse_over_tile(tileData->workspace,eolTrue);
eol_component_list_clear(list);
for (i = 0; i < eol_level_get_tile_set_count(workspace->level);i++)
{
tileType = eol_level_get_tile_set_nth(workspace->level,i);
if (!tileType)
{
eol_logger_message(EOL_LOG_WARN,"editor_tile_workspace_sync:Failed to get %ith tile!\n",i);
continue;
}
eol_list_add_actor_item(list,tileType->id,tileType->actorFile);
}
}
void eol_lighting_close()
{
eol_logger_message(
EOL_LOG_INFO,
"eol_lighting:closing\n"
);
_eol_lighting_initialized = eolFalse;
eol_resource_manager_free(&_eol_lighting_manager);
_eol_lighting_max = 0;
eol_logger_message(
EOL_LOG_INFO,
"eol_lighting:closed\n"
);
}
void eol_level_close()
{
eol_logger_message(
EOL_LOG_INFO,
"eol_level:closing\n"
);
eol_resource_manager_free(&_eol_level_manager);
_eol_level_max = 0;
_eol_level_max_layers = 1;
_eol_level_initialized = eolFalse;
eol_logger_message(
EOL_LOG_INFO,
"eol_level:closed\n"
);
}
eolQuad3D eol_level_layer_get_bounding_quad(eolLevelLayer *layer)
{
eolQuad3D quad =
{
{0,0,0},
{0,0,0},
{0,0,0},
{0,0,0}
};
if (!layer)
{
eol_logger_message(
EOL_LOG_WARN,
"eol_level_layer_get_bounding_quad: passed a bad layer"
);
return quad;
}
quad.t1.x = layer->bounds.x;
quad.t1.y = layer->bounds.y;
quad.t2.x = layer->bounds.x + layer->bounds.w;
quad.t2.y = layer->bounds.y;
quad.t3.x = layer->bounds.x + layer->bounds.w;
quad.t3.y = layer->bounds.y + layer->bounds.h;
quad.t4.x = layer->bounds.x;
quad.t4.y = layer->bounds.y + layer->bounds.h;
return quad;
}
eolBool
eol_armature_descendant_of(
eolArmature *arm,
eolBone *ancestor,
eolBone *descendant
)
{
int p;
if ((descendant == NULL) ||
(arm == NULL) ||
(ancestor == NULL))
{
eol_logger_message(
EOL_LOG_WARN,
"eol_armature: descendant_of passed NULL parameter\n"
);
return eolFalse;
}
if (descendant->hasParent == eolFalse)
{
return eolFalse;
}
p = descendant->parentIndex;
while ((p != -1) && (p < arm->boneCount))
{
if (&arm->_bones[p] == ancestor)
{
return eolTrue;
}
if (!arm->_bones[p].hasParent)break;
p = arm->_bones[p].parentIndex;
}
return eolFalse;
}
void eol_font_draw_text_block(
char * text,
eolInt x,
eolInt y,
eolInt w,
eolInt h,
eolVec3D color,
eolFloat alpha,
eolInt size
)
{
if (!eol_font_initialized())return;
if (size >= eolFontSizeMax)
{
eol_logger_message(
EOL_LOG_WARN,
"eol_font: passed a font size outside of available range");
return;
}
eol_font_draw_text_block_custom(
text,
eol_rect(x,y,w,h),
color,
alpha,
_eol_font_size[size]
);
}
void eol_particle_close()
{
int i;
eol_logger_message(EOL_LOG_INFO,"eol_particle:closing\n");
eol_particle_clear();
for (i = 0;i < _eol_particle_max; i++)
{
eol_particle_delete(&_eol_particle_list[i]);
}
free(_eol_particle_list);
_eol_particle_list = NULL;
_eol_particle_max = 0;
_eol_particle_trail_len = 0;
_eol_particle_initialized = eolFalse;
eol_logger_message(EOL_LOG_INFO,"eol_particle:closed\n");
}
eolFont * eol_font_load(
char *filename,
eolInt pointSize
)
{
eolFont *font = NULL;
font = eol_font_get_by_name_size(filename,pointSize);
if (font != NULL)
{
font->_refCount++;
return font;
}
font = eol_font_new();
if (font == NULL)return NULL;
font->_font = TTF_OpenFont(filename,pointSize);
if(font->_font == NULL)
{
eol_logger_message(
EOL_LOG_ERROR,
"Couldn't initialize Font: %s\n",
SDL_GetError());
eol_font_delete(font);
return NULL;
}
font->point = pointSize;
strncpy(font->filename,filename,EOLLINELEN);
return font;
}
void eol_level_clear_layer_space(eolLevelLayer *layer)
{
if (!layer)
{
return;
}
if (layer->space != NULL)
{
cpSpaceFree(layer->space);
}
layer->space = cpSpaceNew();
if (layer->space == NULL)
{
eol_logger_message(
EOL_LOG_ERROR,
"Unable to create a physics space for new layer!");
eol_level_delete_layer(layer);
return;
}
layer->space->iterations = _eol_level_clip_iterations;
layer->space->sleepTimeThreshold = 999999;
cpSpaceSetEnableContactGraph(layer->space,eolTrue);
cpSpaceSetCollisionSlop(layer->space, _eol_level_slop);
cpSpaceSetCollisionBias(layer->space, _eol_level_bias);
}
void eol_armature_init()
{
eol_logger_message(EOL_LOG_INFO,"eol_armature: initializing\n");
_eol_armature_list = (eolArmature *)malloc(
sizeof(eolArmature)*_eol_armature_max);
if (_eol_armature_list == NULL)
{
eol_logger_message(
EOL_LOG_ERROR,
"eol_armature: cannot allocate armature list!\n");
return;
}
atexit(eol_armature_close);
_eol_armature_initialized = eolTrue;
eol_logger_message(EOL_LOG_INFO,"eol_armature: initialized\n");
}
eolComponent *eol_list_add_actor_item(
eolComponent * list,
eolUint itemId,
eolLine actorFile
)
{
eolRectFloat defaultRect = {0,0,1,1};
eolComponent *actor;
eolComponentList * ldata;
ldata = eol_component_get_list_data(list);
if (!ldata)return NULL;
actor = eol_actor_component_new(
itemId,
actorFile,
defaultRect,
ldata->itemRect,
actorFile,
"",
eolFalse,
eolFalse
);
if (!actor)
{
eol_logger_message(EOL_LOG_WARN,"failed to create actor component from file %s",actorFile);
return NULL;
}
eol_list_add_item(list,actor);
return actor;
}
eolMesh * eol_mesh_new()
{
int i;
if (!eol_mesh_initialized())
{
eol_logger_message(EOL_LOG_ERROR,"eol_mesh:not initialized\n");
return NULL;
}
for (i = 0; i < _eol_mesh_max;i++)
{
if (_eol_mesh_list[i]._refCount == 0)
{
_eol_mesh_list[i]._refCount = 1;
return &_eol_mesh_list[i];
}
}
eol_logger_message(EOL_LOG_WARN,"eol_mesh: out of space for new mesh data.\n");
return NULL;
}
void eol_lighting_init()
{
eol_logger_message(
EOL_LOG_INFO,
"eol_lighting:initializing\n");
_eol_lighting_manager = eol_resource_manager_init(
"eol_lighting_manager",
_eol_lighting_max,
sizeof(eolLight),
eolTrue,
eol_light_delete,
eol_light_load_data_from_file
);
atexit(eol_lighting_close);
eol_logger_message(
EOL_LOG_INFO,
"eol_lighting:initialized\n");
_eol_lighting_initialized = eolTrue;
}
void eol_logger_fatal(char *msg,...)
{
va_list ap;
va_start(ap,msg);
eol_logger_message(
EOL_LOG_FATAL,
msg,
ap);
va_end(ap);
}
void eol_logger_error(char *msg,...)
{
va_list ap;
va_start(ap,msg);
eol_logger_message(
EOL_LOG_ERROR,
msg,
ap);
va_end(ap);
}
void eol_logger_warn(char *msg,...)
{
va_list ap;
va_start(ap,msg);
eol_logger_message(
EOL_LOG_WARN,
msg,
ap);
va_end(ap);
}
/*function definitions*/
void eol_logger_info(char *msg,...)
{
va_list ap;
va_start(ap,msg);
eol_logger_message(
EOL_LOG_INFO,
msg,
ap);
va_end(ap);
}
void eol_component_button_new(eolComponent *component)
{
if (component->componentData != NULL)
{
eol_logger_message(
EOL_LOG_WARN,
"eol_component:tried to make a button out of an existing component\n");
return;
}
component->componentData = malloc(sizeof(eolComponentButton));
if (component->componentData == NULL)
{
eol_logger_message(
EOL_LOG_ERROR,
"eol_actor: failed to allocate data for new button\n");
return;
}
memset(component->componentData,0,sizeof(eolComponentButton));
component->type = eolButtonComponent;
}
void eol_component_entry_new(eolComponent *component)
{
if (component->componentData != NULL)
{
eol_logger_message(
EOL_LOG_WARN,
"eol_component:tried to make a label out of an existing component\n");
return;
}
component->componentData = malloc(sizeof(eolComponentEntry));
if (component->componentData == NULL)
{
eol_logger_message(
EOL_LOG_ERROR,
"eol_actor: failed to allocate data for new label\n");
return;
}
memset(component->componentData,0,sizeof(eolComponentEntry));
component->type = eolEntryComponent;
}
void eol_particle_init()
{
int i;
eol_logger_message(EOL_LOG_INFO,"eol_particle:initializing\n");
_eol_particle_list = (eolParticle *)malloc(sizeof(eolParticle)*_eol_particle_max);
if (_eol_particle_list == NULL)
{
eol_logger_message(
EOL_LOG_ERROR,
"eol_particle: unable to allocate particle list!\n");
return;
}
memset(_eol_particle_list,0,sizeof(eolParticle)*_eol_particle_max);
for (i = 0;i < _eol_particle_max; i++)
{
eol_particle_create(&_eol_particle_list[i]);
}
atexit(eol_particle_close);
_eol_particle_initialized = eolTrue;
eol_logger_message(EOL_LOG_INFO,"eol_particle:initialized\n");
}
void eol_level_init()
{
cpInitChipmunk();
eol_logger_message(
EOL_LOG_INFO,
"eol_level:initializing\n");
_eol_level_manager = eol_resource_manager_init(
"eol_level_manager",
_eol_level_max,
sizeof(eolLevel),
eolTrue,
eol_level_delete,
eol_level_load_data_from_file
);
eol_logger_message(
EOL_LOG_INFO,
"eol_level:initialized\n");
atexit(eol_level_close);
_eol_level_initialized = eolTrue;
}
OriData *editor_orientation_get_data(eolWindow *win)
{
if (!win)return NULL;
if (eol_line_cmp(win->name,"edit_backgrounds_panel") !=0)
{
eol_logger_message(
EOL_LOG_ERROR,
"editor_orientation_get_data: Passed a window not my own");
return NULL;
}
return (OriData*)win->customData;
}
void eol_mat4_print(
eolMat4 mat
)
{
int i,j;
eol_logger_message(
EOL_LOG_INFO,
"matrix:\n");
for (j = 0; j < 4; j++)
{
for (i = 0; i < 4; i++)
{
eol_logger_message(
EOL_LOG_INFO,
"\t%f",mat[j][i]);
}
eol_logger_message(
EOL_LOG_INFO,
"\n");
}
}
void eol_font_init()
{
eol_logger_message(EOL_LOG_INFO,"eol_font: initializing\n");
if (TTF_Init() != 0)
{
eol_logger_message(
EOL_LOG_ERROR,
"eol_font:unable to setup SDL_TTF\n");
return;
}
atexit(TTF_Quit);
atexit(eol_font_close);
_eol_font_list = (eolFont *)malloc(sizeof(eolFont)*_eol_font_max);
memset(_eol_font_list,0,sizeof(eolFont)*_eol_font_max);
_eol_font_initialized = eolTrue;
_eol_font_size[eolFontTiny] = eol_font_load(_eol_default_font,10);
_eol_font_size[eolFontSmall] = eol_font_load(_eol_default_font,12);
_eol_font_size[eolFontMedium] = eol_font_load(_eol_default_font,14);
_eol_font_size[eolFontLarge] = eol_font_load(_eol_default_font,18);
_eol_font_size[eolFontHuge] = eol_font_load(_eol_default_font,24);
eol_logger_message(EOL_LOG_INFO,"eol_font: initialized\n");
}
void eol_armature_close()
{
int i;
eol_logger_message(
EOL_LOG_INFO,
"eol_armature: closing down\n"
);
for (i = 0;i < _eol_armature_max;i++)
{
eol_armature_delete(&_eol_armature_list[i]);
}
if (_eol_armature_list != NULL)
{
free(_eol_armature_list);
_eol_armature_list = NULL;
}
_eol_armature_initialized = eolFalse;
eol_logger_message(
EOL_LOG_INFO,
"eol_armature: closed\n"
);
}
void eol_mesh_init()
{
eol_logger_message(
EOL_LOG_INFO,
"eol_mesh:initializing\n"
);
if (_eol_mesh_list != NULL)return;
_eol_mesh_list = (eolMesh *)malloc(
sizeof(eolMesh) * _eol_mesh_max
);
memset(
_eol_mesh_list,
0,
sizeof(eolMesh) * _eol_mesh_max
);
atexit(eol_mesh_close);
_eol_mesh_initialized = eolTrue;
eol_logger_message(
EOL_LOG_INFO,
"eol_mesh:initialized\n"
);
}
void eol_level_add_mask_to_space(eolLevelLayer *layer)
{
eolBackground *clip;
int i;
int b,n,f;
if (!layer)return;
if (!layer->space)
{
eol_logger_message(
EOL_LOG_ERROR,
"eol_level_add_mask_to_space: cannot add clipmesh to space %s: missing space",
layer->idName);
return;
}
n = g_list_length(layer->backgrounds);
for (b = 0; b < n; b++)
{
clip = g_list_nth_data(layer->backgrounds,b);
if (!clip)continue;
if (!clip->useAsClip)continue;
if (clip->model == NULL)
{
eol_logger_message(EOL_LOG_INFO,"eol_level_add_mask_to_space: clip mesh has no model!");
continue;
}
if (clip->model->_mesh == NULL)
{
eol_logger_message(EOL_LOG_INFO,"eol_level_add_mask_to_space: clip mesh has no mesh data!");
continue;
}
f = clip->model->_mesh->_numFaces;
for (i = 0; i < f;i++)
{
eol_level_add_triangle_to_space(layer->space,
&clip->model->_mesh->_faces[i],
clip->model->_mesh);
}
}
}
void eol_level_clear()
{
if (!eol_level_initialized())
{
eol_logger_message(
EOL_LOG_INFO,
"eol_level:cannot clean, not initialized\n");
return;
}
if (!_eol_level_manager)return;
eol_resource_manager_clean(_eol_level_manager);
}
