/* al_init will call this. */
ALLEGRO_SYSTEM *iphone_initialize(int flags)
{
(void)flags;
iphone = al_calloc(1, sizeof *iphone);
ALLEGRO_SYSTEM *sys = &iphone->system;
iphone->mutex = al_create_mutex();
iphone->cond = al_create_cond();
sys->vt = _al_get_iphone_system_interface();
_al_vector_init(&sys->displays, sizeof (ALLEGRO_DISPLAY_IPHONE *));
_al_unix_init_time();
_al_iphone_init_path();
return sys;
}
/* [user thread] */
bool _al_gtk_init_args(void *ptr, size_t size)
{
ARGS_BASE *args = (ARGS_BASE *)ptr;
memset(args, 0, size);
args->mutex = al_create_mutex();
if (!args->mutex) {
return false;
}
args->cond = al_create_cond();
if (!args->cond) {
al_destroy_mutex(args->mutex);
return false;
}
args->done = false;
args->response = true;
return args;
}
/* initialises the input emulation */
void init_input()
{
ALLEGRO_JOYSTICK *joy;
keybuf_len = 0;
keybuf_mutex = al_create_mutex();
input_queue = al_create_event_queue();
al_register_event_source(input_queue, al_get_keyboard_event_source());
al_register_event_source(input_queue, al_get_display_event_source(
al_get_current_display()));
if (al_get_num_joysticks() > 0) {
joy = al_get_joystick(0);
if (joy)
al_register_event_source(input_queue, al_get_joystick_event_source(joy));
}
}
static bool t3f_set_music_state(int state)
{
/* create the mutex if necessary */
if(!t3f_music_state_mutex)
{
t3f_music_state_mutex = al_create_mutex();
if(!t3f_music_state_mutex)
{
return false;
}
}
al_lock_mutex(t3f_music_state_mutex);
t3f_music_state = state;
al_unlock_mutex(t3f_music_state_mutex);
return true;
}
/* Function: al_create_voice
*/
ALLEGRO_VOICE *al_create_voice(unsigned int freq,
ALLEGRO_AUDIO_DEPTH depth, ALLEGRO_CHANNEL_CONF chan_conf)
{
ALLEGRO_VOICE *voice = NULL;
if (!freq) {
_al_set_error(ALLEGRO_INVALID_PARAM, "Invalid Voice Frequency");
return NULL;
}
voice = al_calloc(1, sizeof(*voice));
if (!voice) {
return NULL;
}
voice->depth = depth;
voice->chan_conf = chan_conf;
voice->frequency = freq;
voice->mutex = al_create_mutex();
voice->cond = al_create_cond();
/* XXX why is this needed? there should only be one active driver */
voice->driver = _al_kcm_driver;
ASSERT(_al_kcm_driver);
if (_al_kcm_driver->allocate_voice(voice) != 0) {
al_destroy_mutex(voice->mutex);
al_destroy_cond(voice->cond);
al_free(voice);
return NULL;
}
_al_kcm_register_destructor("voice", voice,
(void (*)(void *)) al_destroy_voice);
return voice;
}
int main(void)
{
ALLEGRO_THREAD *thread[NUM_THREADS];
ALLEGRO_DISPLAY *display;
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
bool need_draw;
int i;
for (i = 0; i < 256; i++) {
sin_lut[i] = 128 + (int) (127.0 * sin(i / 8.0));
}
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_install_keyboard();
al_install_mouse();
display = al_create_display(W * IMAGES_PER_ROW,
H * NUM_THREADS / IMAGES_PER_ROW);
if (!display) {
abort_example("Error creating display\n");
return 1;
}
timer = al_install_timer(1.0/3);
if (!timer) {
abort_example("Error creating timer\n");
return 1;
}
queue = al_create_event_queue();
if (!queue) {
abort_example("Error creating event queue\n");
return 1;
}
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_mouse_event_source());
al_register_event_source(queue, al_get_timer_event_source(timer));
/* Note:
* Right now, A5 video displays can only be accessed from the thread which
* created them (at lesat for OpenGL). To lift this restriction, we could
* keep track of the current OpenGL context for each thread and make all
* functions accessing the display check for it.. not sure it's worth the
* additional complexity though.
*/
al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_RGB_888);
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
for (i = 0; i < NUM_THREADS; i++) {
thread_info[i].bitmap = al_create_bitmap(W, H);
if (!thread_info[i].bitmap) {
goto Error;
}
thread_info[i].mutex = al_create_mutex();
if (!thread_info[i].mutex) {
goto Error;
}
thread_info[i].cond = al_create_cond();
if (!thread_info[i].cond) {
goto Error;
}
thread_info[i].is_paused = false;
thread_info[i].random_seed = i;
thread[i] = al_create_thread(thread_func, &thread_info[i]);
if (!thread[i]) {
goto Error;
}
}
set_target(0, -0.56062033041600878303, -0.56064322926933807256);
set_target(1, -0.57798076669230014080, -0.63449861991138123418);
set_target(2, 0.36676836392830602929, -0.59081385302214906030);
set_target(3, -1.48319283039401317303, -0.00000000200514696273);
set_target(4, -0.74052910500707636032, 0.18340899525730713915);
set_target(5, 0.25437906525768350097, -0.00046678223345789554);
set_target(6, -0.56062033041600878303, 0.56064322926933807256);
set_target(7, -0.57798076669230014080, 0.63449861991138123418);
set_target(8, 0.36676836392830602929, 0.59081385302214906030);
for (i = 0; i < NUM_THREADS; i++) {
al_start_thread(thread[i]);
}
al_start_timer(timer);
need_draw = true;
while (true) {
if (need_draw && al_event_queue_is_empty(queue)) {
show_images();
need_draw = false;
}
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_TIMER) {
need_draw = true;
}
else if (event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) {
int n = (event.mouse.y / H) * IMAGES_PER_ROW + (event.mouse.x / W);
if (n < NUM_THREADS) {
double x = event.mouse.x - (event.mouse.x / W) * W;
double y = event.mouse.y - (event.mouse.y / H) * H;
/* Center to the mouse click position. */
if (thread_info[n].is_paused) {
thread_info[n].target_x = x / W - 0.5;
thread_info[n].target_y = y / H - 0.5;
}
toggle_pausedness(n);
}
}
else if (event.type == ALLEGRO_EVENT_DISPLAY_EXPOSE) {
need_draw = true;
}
else if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
else if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
break;
}
need_draw = true;
}
}
for (i = 0; i < NUM_THREADS; i++) {
/* Set the flag to stop the thread. The thread might be waiting on a
* condition variable, so signal the condition to force it to wake up.
*/
al_set_thread_should_stop(thread[i]);
al_lock_mutex(thread_info[i].mutex);
al_broadcast_cond(thread_info[i].cond);
al_unlock_mutex(thread_info[i].mutex);
/* al_destroy_thread() implicitly joins the thread, so this call is not
* strictly necessary.
*/
al_join_thread(thread[i], NULL);
al_destroy_thread(thread[i]);
}
al_destroy_event_queue(queue);
al_uninstall_timer(timer);
al_destroy_display(display);
return 0;
Error:
return 1;
}
static void packet_queue_init(PacketQueue * q)
{
memset(q, 0, sizeof(PacketQueue));
q->mutex = al_create_mutex();
q->cond = al_create_cond();
}
static bool open_video(ALLEGRO_VIDEO *video)
{
VideoState *is = av_mallocz(sizeof *is);
int i;
AVRational fps;
is->video = video;
init();
video->data = is;
strncpy(is->filename, al_path_cstr(video->filename, '/'),
sizeof(is->filename));
is->av_sync_type = DEFAULT_AV_SYNC_TYPE;
// Open video file
#ifdef FFMPEG_0_8
if (avformat_open_input(&is->format_context, is->filename, NULL,
NULL) != 0) {
#else
if (av_open_input_file(&is->format_context, is->filename, NULL, 0,
NULL) != 0) {
#endif
av_free(is);
return false;
}
if (av_find_stream_info(is->format_context) < 0) {
av_free(is);
return false;
}
is->video_index = -1;
is->audio_index = -1;
for (i = 0; i < (int)is->format_context->nb_streams; i++) {
if (is->format_context->streams[i]->codec->codec_type
== AVMEDIA_TYPE_VIDEO && is->video_index < 0)
{
is->video_index = i;
}
if (is->format_context->streams[i]->codec->codec_type
== AVMEDIA_TYPE_AUDIO && is->audio_index < 0)
{
is->audio_index = i;
}
}
fps = is->format_context->streams[is->video_index]->r_frame_rate;
video->fps = (double)fps.num / fps.den;
video->audio_rate = is->format_context->streams[is->audio_index]->
codec->sample_rate;
video->width = is->format_context->streams[is->video_index]->codec->width;
video->height = is->format_context->streams[is->video_index]->codec->height;
is->pictq_mutex = al_create_mutex();
is->pictq_cond = al_create_cond();
is->timer_mutex = al_create_mutex();
is->timer_cond = al_create_cond();
return true;
}
static bool close_video(ALLEGRO_VIDEO *video)
{
VideoState *is = video->data;
is->quit = true;
if (is->timer_thread) {
al_lock_mutex(is->timer_mutex);
al_signal_cond(is->timer_cond);
al_unlock_mutex(is->timer_mutex);
al_join_thread(is->timer_thread, NULL);
}
if (is->parse_thread) {
al_join_thread(is->parse_thread, NULL);
}
al_destroy_mutex(is->timer_mutex);
al_destroy_cond(is->timer_cond);
av_free(is);
return true;
}
void main_loop(ALLEGRO_EVENT_QUEUE *event_queue) {
int color = 0, c2 = 0, c3 = 0;
bool stlacene_tlacitka[ALLEGRO_KEY_MAX];
memset(stlacene_tlacitka, 0, sizeof(stlacene_tlacitka));
struct Player *player;
player = player_new();
struct Objekt * obj = malloc(sizeof(struct Objekt));
list_add(&scena, obj);
obj->objekt = player;
obj->draw = player_draw;
obj->destroy = player_destroy;
obj->copy = player_copy;
mutex = al_create_mutex();
ALLEGRO_THREAD *thread = al_create_thread(kresliace_vlakno, event_queue);
al_start_thread(thread);
for (;;) {
ALLEGRO_EVENT event;
al_wait_for_event(event_queue, &event);
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
if (event.type == ALLEGRO_EVENT_TIMER) {
al_lock_mutex(mutex);
if (stlacene_tlacitka[ALLEGRO_KEY_LEFT]) {
player->x = player->x - 10;
if (player->x < 0) player->x = 0;
}
if (stlacene_tlacitka[ALLEGRO_KEY_RIGHT]) {
player->x = player->x + 10;
if (player->x > SCREEN_W - 64) player->x = SCREEN_W - 64;
}
al_unlock_mutex(mutex);
}
if (event.type == ALLEGRO_EVENT_KEY_DOWN
||event.type == ALLEGRO_EVENT_KEY_UP) {
ALLEGRO_KEYBOARD_STATE stav_klavesnice;
al_get_keyboard_state(&stav_klavesnice);
if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_ESCAPE)) {
break;
}
if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_LEFT)) {
stlacene_tlacitka[ALLEGRO_KEY_LEFT] = true;
} else {
stlacene_tlacitka[ALLEGRO_KEY_LEFT] = false;
}
if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_RIGHT)) {
stlacene_tlacitka[ALLEGRO_KEY_RIGHT] = true;
} else {
stlacene_tlacitka[ALLEGRO_KEY_RIGHT] = false;
}
if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_UP)) {
stlacene_tlacitka[ALLEGRO_KEY_UP] = true;
} else {
stlacene_tlacitka[ALLEGRO_KEY_UP] = false;
}
if (al_key_down(&stav_klavesnice, ALLEGRO_KEY_DOWN)) {
stlacene_tlacitka[ALLEGRO_KEY_DOWN] = true;
} else {
stlacene_tlacitka[ALLEGRO_KEY_DOWN] = false;
}
}
}
al_destroy_thread(thread);
}
/* return the player so you can use more advanced features if you want
you can safely ignore the return value if all you want is to play a mod */
DUMBA5_PLAYER * dumba5_create_player(DUH * dp, int pattern, bool loop, int bufsize, int frequency, bool stereo)
{
DUMBA5_PLAYER * player;
ALLEGRO_CHANNEL_CONF c_conf;
int n_channels = 2;
/* This restriction is imposed by Allegro. */
ASSERT(n_channels > 0);
ASSERT(n_channels <= 2);
if(!dp)
{
return NULL;
}
player = (DUMBA5_PLAYER *) malloc(sizeof(DUMBA5_PLAYER));
if(!player)
{
return NULL;
}
player->flags = 0;
player->bufsize = bufsize;
player->freq = frequency;
player->channels = n_channels;
if(n_channels == 1)
{
c_conf = ALLEGRO_CHANNEL_CONF_1;
}
else
{
c_conf = ALLEGRO_CHANNEL_CONF_2;
}
player->stream = al_create_audio_stream(4, bufsize, frequency, ALLEGRO_AUDIO_DEPTH_INT16, c_conf);
if(!player->stream)
{
free(player);
return NULL;
}
al_attach_audio_stream_to_mixer(player->stream, al_get_default_mixer());
player->sigrenderer = dumb_it_start_at_order(dp, n_channels, pattern);
if(!player->sigrenderer)
{
al_destroy_audio_stream(player->stream);
free(player);
return NULL;
}
player->mutex = al_create_mutex();
if(!player->mutex)
{
return NULL;
}
player->thread = al_create_thread(dumba5_update_thread, player);
if(!player->thread)
{
return NULL;
}
player->volume = 1.0;
player->silentcount = 0;
player->duh = dp;
return player;
}
void _al_glsl_init_shaders(void)
{
_al_vector_init(&shaders, sizeof(ALLEGRO_SHADER *));
shaders_mutex = al_create_mutex();
}
NINE_PATCH_BITMAP *create_nine_patch_bitmap(ALLEGRO_BITMAP *bmp, bool owns_bitmap)
{
int i;
NINE_PATCH_BITMAP *p9;
ALLEGRO_COLOR c;
p9 = al_malloc(sizeof(*p9));
p9->bmp = bmp;
p9->destroy_bmp = owns_bitmap;
p9->h.m = NULL;
p9->v.m = NULL;
p9->cached_dw = 0;
p9->cached_dh = 0;
p9->mutex = al_create_mutex();
p9->width = al_get_bitmap_width(bmp) - 2;
p9->height = al_get_bitmap_height(bmp) - 2;
al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY);
if (p9->width <= 0 || p9->height <= 0)
goto bad_bitmap;
/* make sure all four corners are transparent */
#define _check_pixel(x, y) \
c = al_get_pixel(bmp, x, y); \
if (c.a != 0 && c.r + c.g + c.b + c.a != 4) goto bad_bitmap;
_check_pixel(0,0);
_check_pixel(al_get_bitmap_width(bmp) - 1, 0);
_check_pixel(0, al_get_bitmap_height(bmp) - 1);
_check_pixel(al_get_bitmap_width(bmp) - 1, al_get_bitmap_height(bmp) - 1);
#undef _check_pixel
p9->padding.top = p9->padding.right = p9->padding.bottom = p9->padding.left = -1;
i = 1;
while (i < al_get_bitmap_width(bmp))
{
c = al_get_pixel(bmp, i, al_get_bitmap_height(bmp) - 1);
if (c.r + c.g + c.b == 0 && c.a == 1)
{
if (p9->padding.left == -1)
p9->padding.left = i - 1;
else if (p9->padding.right != -1)
goto bad_bitmap;
}
else if (c.a == 0 || c.r + c.g + c.b + c.a == 4)
{
if (p9->padding.left != -1 && p9->padding.right == -1)
p9->padding.right = al_get_bitmap_width(bmp) - i - 1;
}
++i;
}
i = 1;
while (i < al_get_bitmap_height(bmp))
{
c = al_get_pixel(bmp, al_get_bitmap_width(bmp) - 1, i);
if (c.r + c.g + c.b == 0 && c.a == 1)
{
if (p9->padding.top == -1)
p9->padding.top = i - 1;
else if (p9->padding.bottom != -1)
goto bad_bitmap;
}
else if (c.a == 0 || c.r + c.g + c.b + c.a == 4)
{
if (p9->padding.top != -1 && p9->padding.bottom == -1)
p9->padding.bottom = al_get_bitmap_height(bmp) - i - 1;
}
++i;
}
if (!init_nine_patch_side(&p9->h, bmp, 0) || !init_nine_patch_side(&p9->v, bmp, 1))
{
bad_bitmap:
al_destroy_mutex(p9->mutex);
if (p9->h.m) al_free(p9->h.m);
if (p9->v.m) al_free(p9->v.m);
al_free(p9);
p9 = NULL;
}
al_unlock_bitmap(bmp);
return p9;
}
static int pulseaudio_allocate_voice(ALLEGRO_VOICE *voice)
{
PULSEAUDIO_VOICE *pv = al_malloc(sizeof(PULSEAUDIO_VOICE));
pa_sample_spec ss;
pa_buffer_attr ba;
ss.channels = al_get_channel_count(voice->chan_conf);
ss.rate = voice->frequency;
if (voice->depth == ALLEGRO_AUDIO_DEPTH_UINT8)
ss.format = PA_SAMPLE_U8;
else if (voice->depth == ALLEGRO_AUDIO_DEPTH_INT16)
ss.format = PA_SAMPLE_S16NE;
#if PA_API_VERSION > 11
else if (voice->depth == ALLEGRO_AUDIO_DEPTH_INT24)
ss.format = PA_SAMPLE_S24NE;
#endif
else if (voice->depth == ALLEGRO_AUDIO_DEPTH_FLOAT32)
ss.format = PA_SAMPLE_FLOAT32NE;
else {
ALLEGRO_ERROR("Unsupported PulseAudio sound format.\n");
al_free(pv);
return 1;
}
ba.maxlength = 0x10000; // maximum length of buffer
ba.tlength = 0x2000; // target length of buffer
ba.prebuf = -1; // minimum data size required before playback starts
// set to -1 to work with the simple API.
ba.minreq = 0; // minimum size of request
ba.fragsize = -1; // fragment size (recording)
pv->s = pa_simple_new(
NULL, // Use the default server.
al_get_app_name(),
PA_STREAM_PLAYBACK,
NULL, // Use the default device.
"Allegro Voice",
&ss,
NULL, // Use default channel map
&ba,
NULL // Ignore error code.
);
if (!pv->s) {
al_free(pv);
return 1;
}
voice->extra = pv;
pv->buffer_size_in_frames = get_buffer_size(al_get_system_config());
pv->frame_size_in_bytes = ss.channels * al_get_audio_depth_size(voice->depth);
pv->status = PV_IDLE;
//pv->status_mutex = al_create_mutex();
pv->status_cond = al_create_cond();
pv->buffer_mutex = al_create_mutex();
pv->poll_thread = al_create_thread(pulseaudio_update, (void*)voice);
al_start_thread(pv->poll_thread);
return 0;
}
//initializes the resource manager; invoked from algui_init
int _algui_init_resource_manager() {
_mutex = al_create_mutex();
if (!_mutex) return 0;
return 1;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
bool redraw = true;
ALLEGRO_FONT *font;
ALLEGRO_BITMAP *spin, *spin2;
int current_bitmap = 0;
int loaded_bitmap = 0;
ALLEGRO_THREAD *thread;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_init_image_addon();
al_init_font_addon();
al_init_primitives_addon();
init_platform_specific();
open_log();
al_install_mouse();
al_install_keyboard();
spin = al_load_bitmap("data/cursor.tga");
log_printf("default bitmap without display: %p\n", spin);
al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP);
spin2 = al_load_bitmap("data/cursor.tga");
log_printf("video bitmap without display: %p\n", spin2);
log_printf("%p before create_display: ", spin);
print_bitmap_flags(spin);
log_printf("\n");
display = al_create_display(64, 64);
if (!display) {
abort_example("Error creating display\n");
}
spin2 = al_load_bitmap("data/cursor.tga");
log_printf("video bitmap with display: %p\n", spin2);
log_printf("%p after create_display: ", spin);
print_bitmap_flags(spin);
log_printf("\n");
log_printf("%p after create_display: ", spin2);
print_bitmap_flags(spin2);
log_printf("\n");
al_destroy_display(display);
log_printf("%p after destroy_display: ", spin);
print_bitmap_flags(spin);
log_printf("\n");
log_printf("%p after destroy_display: ", spin2);
print_bitmap_flags(spin2);
log_printf("\n");
display = al_create_display(640, 480);
log_printf("%p after create_display: ", spin);
print_bitmap_flags(spin);
log_printf("\n");
log_printf("%p after create_display: ", spin2);
print_bitmap_flags(spin2);
log_printf("\n");
font = al_load_font("data/fixed_font.tga", 0, 0);
mutex = al_create_mutex();
thread = al_create_thread(loading_thread, NULL);
al_start_thread(thread);
timer = al_create_timer(1.0 / 30);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
while (1) {
ALLEGRO_EVENT event;
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
break;
}
if (event.type == ALLEGRO_EVENT_TIMER)
redraw = true;
if (redraw && al_is_event_queue_empty(queue)) {
float x = 20, y = 320;
int i;
ALLEGRO_COLOR color = al_map_rgb_f(0, 0, 0);
float t = al_current_time();
redraw = false;
al_clear_to_color(al_map_rgb_f(0.5, 0.6, 1));
al_draw_textf(font, color, x + 40, y, 0, "Loading %d%%",
100 * load_count / load_total);
al_lock_mutex(mutex);
if (loaded_bitmap < load_count) {
/* This will convert any video bitmaps without a display
* (all the bitmaps being loaded in the loading_thread) to
* video bitmaps we can use in the main thread.
*/
al_convert_bitmap(bitmaps[loaded_bitmap]);
loaded_bitmap++;
}
al_unlock_mutex(mutex);
if (current_bitmap < loaded_bitmap) {
int bw;
al_draw_bitmap(bitmaps[current_bitmap], 0, 0, 0);
if (current_bitmap + 1 < loaded_bitmap)
current_bitmap++;
for (i = 0; i <= current_bitmap; i++) {
bw = al_get_bitmap_width(bitmaps[i]);
al_draw_scaled_rotated_bitmap(bitmaps[i],
0, 0, (i % 20) * 640 / 20, 360 + (i / 20) * 24,
32.0 / bw, 32.0 / bw, 0, 0);
}
}
if (loaded_bitmap < load_total) {
al_draw_scaled_rotated_bitmap(spin,
16, 16, x, y, 1.0, 1.0, t * ALLEGRO_PI * 2, 0);
}
al_flip_display();
}
}
al_join_thread(thread, NULL);
al_destroy_mutex(mutex);
al_destroy_font(font);
al_destroy_display(display);
close_log(true);
return 0;
}
Framework::Framework()
{
#ifdef WRITE_LOG
printf( "Framework: Startup\n" );
#endif
// Init Allegro
if( !al_init() )
{
return;
}
al_init_font_addon();
if( !al_install_keyboard() || !al_install_mouse() || !al_init_primitives_addon() || !al_init_ttf_addon() || !al_init_image_addon() )
{
return;
}
if( al_install_joystick() )
{
al_reconfigure_joysticks();
}
audioInitialised = false;
InitialiseAudioSystem();
std::string selectedLanguage;
quitProgram = false;
ProgramStages = new StageStack();
framesToProcess = 0;
Settings = new ConfigFile( "settings.cfg" );
eventQueue = al_create_event_queue();
InitialiseDisplay();
al_register_event_source( eventQueue, al_get_keyboard_event_source() );
al_register_event_source( eventQueue, al_get_mouse_event_source() );
fpsTimer = al_create_timer( 1.0 / (float)FRAMES_PER_SECOND );
al_register_event_source( eventQueue, al_get_timer_event_source( fpsTimer ) );
al_start_timer( fpsTimer );
al_hide_mouse_cursor( displaySurface );
imageMgr = new ImageManager( this );
fontMgr = new FontManager( this );
audioMgr = new AudioManager( this );
int maxDownloads = 4;
if( Settings->KeyExists( "Downloads.MaxConcurrentDownloads" ) )
{
Settings->GetIntegerValue( "Downloads.MaxConcurrentDownloads", &maxDownloads );
}
downloadMgr = new DownloadManager( this, maxDownloads );
networkMgr = new NetworkManager( this );
languageMgr = new LanguageManager();
if( Settings->KeyExists( "Application.Language" ) )
{
Settings->GetStringValue( "Application.Language", &selectedLanguage );
languageMgr->SetActiveLanguage( selectedLanguage );
}
NativePlatform = new Platform();
SystemFramework = this;
extraEventsMutex = al_create_mutex();
}
DATA() : mutex(al_create_mutex()),
cond(al_create_cond()),
posiX (0),
posiY (0),
modi_X(false),
ready (false) {}