void init_error_bitmap() {
// Error bitmap.
int bmp_error_w, bmp_error_h;
al_get_text_dimensions(al_create_builtin_font(), "ERROR", NULL, NULL, &bmp_error_w, &bmp_error_h);
bmp_error = al_create_bitmap(bmp_error_w, bmp_error_h);
al_set_target_bitmap(bmp_error); {
al_clear_to_color(al_map_rgba(64, 0, 0, 128));
al_draw_text(al_create_builtin_font(), al_map_rgb(255, 0, 0), 0, 0, 0, "ERROR");
} al_set_target_backbuffer(display);
}
Font::Font(void)
{
disposed = false;
is_set = false;
rage_file = Qnil;
font = al_create_builtin_font();
}
void
init_video (void)
{
if (! al_init_image_addon ())
error (-1, 0, "%s (void): failed to initialize image addon",
__func__);
al_set_new_display_flags (al_get_new_display_flags ()
| (display_mode < 0 ? ALLEGRO_WINDOWED : ALLEGRO_FULLSCREEN)
| ALLEGRO_RESIZABLE
| ALLEGRO_GENERATE_EXPOSE_EVENTS);
display_width = display_width ? display_width : DISPLAY_WIDTH;
display_height = display_height ? display_height : DISPLAY_HEIGHT;
if (display_mode >= 0) {
ALLEGRO_DISPLAY_MODE d;
get_display_mode (display_mode, &d);
display_width = d.width;
display_height = d.height;
al_set_new_display_refresh_rate (d.refresh_rate);
al_set_new_display_flags (al_get_new_display_flags ()
& ~ALLEGRO_FULLSCREEN_WINDOW);
}
al_set_new_display_option (ALLEGRO_SINGLE_BUFFER, 1, ALLEGRO_SUGGEST);
display = al_create_display (display_width, display_height);
if (! display) error (-1, 0, "%s (void): failed to initialize display", __func__);
set_target_backbuffer (display);
al_set_new_bitmap_flags (ALLEGRO_VIDEO_BITMAP);
al_set_window_title (display, WINDOW_TITLE);
icon = load_bitmap (ICON);
al_set_display_icon (display, icon);
cutscene = true;
if (mr.fit_w == 0 && mr.fit_h == 0) {
mr.fit_w = 2;
mr.fit_h = 2;
}
set_multi_room (1, 1);
effect_buffer = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
black_screen = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
uscreen = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
iscreen = create_bitmap (display_width, display_height);
clear_bitmap (uscreen, TRANSPARENT_COLOR);
video_timer = create_timer (1.0 / EFFECT_HZ);
al_init_font_addon ();
builtin_font = al_create_builtin_font ();
if (! builtin_font)
error (-1, 0, "%s (void): cannot create builtin font", __func__);
if (! al_init_primitives_addon ())
error (-1, 0, "%s (void): failed to initialize primitives addon",
__func__);
}
void About(struct Game *game, struct MenuResources* data) {
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_use_transform(&trans);
if (!game->_priv.font_bsod) {
game->_priv.font_bsod = al_create_builtin_font();
}
al_set_target_backbuffer(game->display);
al_clear_to_color(al_map_rgb(0,0,170));
char *header = "TICKLE MONSTER";
al_draw_filled_rectangle(al_get_display_width(game->display)/2 - al_get_text_width(game->_priv.font_bsod, header)/2 - 4, (int)(al_get_display_height(game->display) * 0.32), 4 + al_get_display_width(game->display)/2 + al_get_text_width(game->_priv.font_bsod, header)/2, (int)(al_get_display_height(game->display) * 0.32) + al_get_font_line_height(game->_priv.font_bsod), al_map_rgb(170,170,170));
al_draw_text(game->_priv.font_bsod, al_map_rgb(0, 0, 170), al_get_display_width(game->display)/2, (int)(al_get_display_height(game->display) * 0.32), ALLEGRO_ALIGN_CENTRE, header);
char *header2 = "A fatal exception 0xD3RP has occured at 0028:M00F11NZ in GST SD(01) +";
al_draw_text(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2, (int)(al_get_display_height(game->display) * 0.32+2*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_CENTRE, header2);
al_draw_textf(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2 - al_get_text_width(game->_priv.font_bsod, header2)/2, (int)(al_get_display_height(game->display) * 0.32+3*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_LEFT, "%p and system just doesn't know what went wrong.", (void*)game);
al_draw_text(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2, (int)(al_get_display_height(game->display) * 0.32+5*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_CENTRE, "About screen not implemented!");
al_draw_text(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2, (int)(al_get_display_height(game->display) * 0.32+6*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_CENTRE, "See http://dosowisko.net/ticklemonster/");
al_draw_text(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2, (int)(al_get_display_height(game->display) * 0.32+7*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_CENTRE, "Made for Ludum Dare 33 by Sebastian Krzyszkowiak");
al_draw_text(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2 - al_get_text_width(game->_priv.font_bsod, header2)/2, (int)(al_get_display_height(game->display) * 0.32+9*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_LEFT, "* Press any key to terminate this error.");
al_draw_text(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2 - al_get_text_width(game->_priv.font_bsod, header2)/2, (int)(al_get_display_height(game->display) * 0.32+10*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_LEFT, "* Press any key to destroy all muffins in the world.");
al_draw_text(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2 - al_get_text_width(game->_priv.font_bsod, header2)/2, (int)(al_get_display_height(game->display) * 0.32+11*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_LEFT, "* Just kidding, please press any key anyway.");
al_draw_text(game->_priv.font_bsod, al_map_rgb(255,255,255), al_get_display_width(game->display)/2, (int)(al_get_display_height(game->display) * 0.32+13*al_get_font_line_height(game->_priv.font_bsod)*1.25), ALLEGRO_ALIGN_CENTRE, "Press any key to continue _");
al_use_transform(&game->projection);
}
bool Framework::initialize(std::string config_filename)
{
if (initialized) return initialized;
if (!al_init()) std::cerr << "al_init() failed" << std::endl;
ALLEGRO_PATH *resource_path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_change_directory(al_path_cstr(resource_path, ALLEGRO_NATIVE_PATH_SEP));
al_destroy_path(resource_path);
if (!al_install_mouse()) std::cerr << "al_install_mouse() failed" << std::endl;
if (!al_install_keyboard()) std::cerr << "al_install_keyboard() failed" << std::endl;
if (!al_install_joystick()) std::cerr << "al_install_joystick() failed" << std::endl;
if (!al_install_audio()) std::cerr << "al_install_audio() failed" << std::endl;
if (!al_init_native_dialog_addon()) std::cerr << "al_init_native_dialog_addon() failed" << std::endl;
if (!al_init_primitives_addon()) std::cerr << "al_init_primitives_addon() failed" << std::endl;
if (!al_init_image_addon()) std::cerr << "al_init_image_addon() failed" << std::endl;
if (!al_init_font_addon()) std::cerr << "al_init_font_addon() failed" << std::endl;
if (!al_init_ttf_addon()) std::cerr << "al_init_ttf_addon() failed" << std::endl;
if (!al_init_acodec_addon()) std::cerr << "al_init_acodec_addon() failed" << std::endl;
if (!al_reserve_samples(32)) std::cerr << "al_reserve_samples() failed" << std::endl;
srand(time(NULL));
primary_timer = al_create_timer(ALLEGRO_BPS_TO_SECS(60));
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
// al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR | ALLEGRO_MIPMAP);
builtin_font = al_create_builtin_font();
event_queue = al_create_event_queue();
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_joystick_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(primary_timer));
al_register_event_source(event_queue, al_get_joystick_event_source());
al_register_event_source(event_queue, al_get_default_menu_event_source());
if (al_get_num_joysticks()) joystick = al_get_joystick(0); // make this better eventually
else std::cerr << "no joystick(s) detected" << std::endl;
instance = new Framework(config_filename);
Attributes::create_datatype_definition(
AllegroColorAttributeDatatype::IDENTIFIER,
AllegroColorAttributeDatatype::to_val_func,
AllegroColorAttributeDatatype::to_str_func
);
initialized = true;
return true;
}
static Profiler *get_instance()
{
if (!instance)
{
instance = new Profiler;
bg_color = al_color_name("black");
bar_color = al_color_name("orange");
font_color = al_color_name("white");
limit_bar_color = al_color_name("lightblue");
font = al_create_builtin_font();
}
return instance;
}
void init_allegro(){
if(!al_init()) {
fprintf(stderr, "Failed to initialize allegro!\n");
}
if(!al_install_keyboard()) {
fprintf(stderr, "Failed to initialize the keyboard!\n");
}
if(!al_init_primitives_addon()) {
fprintf(stderr, "failed to create primitives addon!\n");
}
al_init_font_addon();
default_font = al_create_builtin_font();
if (!default_font)
fprintf(stderr, "Failed to create builtin font");
timer = al_create_timer(1.0 / FPS);
if(!timer) {
fprintf(stderr, "failed to create timer!\n");
}
display = al_create_display(SCREEN_WIDTH, SCREEN_HEIGHT);
if(!display){
fprintf(stderr, "Failed to create display!\n");
}
event_queue = al_create_event_queue();
if(!event_queue) {
fprintf(stderr, "failed to create event_queue!\n");
}
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
atexit(destroy_allegro);
}
void
error_display(const char *text)
{
ALLEGRO_DISPLAY *disp;
ALLEGRO_EVENT_QUEUE *ev_queue;
ALLEGRO_FONT *font;
al_init();
al_install_keyboard();
al_install_mouse();
al_init_font_addon();
al_set_new_display_flags(ALLEGRO_WINDOWED);
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
disp = al_create_display(640, 480);
al_set_window_title(disp, "mruby-minigame");
ev_queue = al_create_event_queue();
al_register_event_source(ev_queue, al_get_display_event_source(disp));
al_register_event_source(ev_queue, al_get_keyboard_event_source());
al_register_event_source(ev_queue, al_get_mouse_event_source());
font = al_create_builtin_font();
for (;;) {
ALLEGRO_EVENT ev;
while (al_get_next_event(ev_queue, &ev)) {
if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) goto done;
}
al_clear_to_color(al_map_rgb(200, 120, 120));
al_draw_multiline_text(font, al_map_rgb(255, 255, 255), 64, 64, 640-64, 10, ALLEGRO_ALIGN_LEFT, text);
al_flip_display();
}
done:
return;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display, *ms_display;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_TIMER *timer;
ALLEGRO_BITMAP *memory;
char title[1024];
bool quit = false;
bool redraw = true;
int wx, wy;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Couldn't initialise Allegro.\n");
}
al_init_primitives_addon();
al_install_keyboard();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
memory = create_bitmap();
/* Create the normal display. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 0, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_SAMPLES, 0, ALLEGRO_SUGGEST);
display = al_create_display(300, 450);
if (!display) {
abort_example("Error creating display\n");
}
al_set_window_title(display, "Normal");
/* Create bitmaps for the normal display. */
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
bitmap_filter = al_clone_bitmap(memory);
al_set_new_bitmap_flags(0);
bitmap_normal = al_clone_bitmap(memory);
font = al_create_builtin_font();
al_get_window_position(display, &wx, &wy);
if (wx < 160)
wx = 160;
/* Create the multi-sampling display. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
ms_display = al_create_display(300, 450);
if (!ms_display) {
abort_example("Multisampling not available.\n");
}
sprintf(title, "Multisampling (%dx)", al_get_display_option(
ms_display, ALLEGRO_SAMPLES));
al_set_window_title(ms_display, title);
/* Create bitmaps for the multi-sampling display. */
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
bitmap_filter_ms = al_clone_bitmap(memory);
al_set_new_bitmap_flags(0);
bitmap_normal_ms = al_clone_bitmap(memory);
font_ms = al_create_builtin_font();
/* Move the windows next to each other, because some window manager
* would put them on top of each other otherwise.
*/
al_set_window_position(display, wx - 160, wy);
al_set_window_position(ms_display, wx + 160, wy);
timer = al_create_timer(1.0 / 30.0);
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_display_event_source(ms_display));
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
while (!quit) {
ALLEGRO_EVENT event;
/* Check for ESC key or close button event and quit in either case. */
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
quit = true;
break;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
quit = true;
break;
case ALLEGRO_EVENT_TIMER:
bitmap_move();
redraw = true;
break;
}
if (redraw && al_is_event_queue_empty(queue)) {
/* Draw the multi-sampled version into the first window. */
al_set_target_backbuffer(ms_display);
al_clear_to_color(al_map_rgb_f(1, 1, 1));
draw(bitmap_filter_ms, 0, "filtered, multi-sample");
draw(bitmap_normal_ms, 250, "no filter, multi-sample");
al_flip_display();
/* Draw the normal version into the second window. */
al_set_target_backbuffer(display);
al_clear_to_color(al_map_rgb_f(1, 1, 1));
draw(bitmap_filter, 0, "filtered");
draw(bitmap_normal, 250, "no filter");
al_flip_display();
redraw = false;
}
}
return 0;
}
bool Renderer::init(Minecraft *mc, const char *argv0)
{
NBT_Debug("begin");
al_set_org_name("mctools");
al_set_app_name("viewer");
if(!al_init())
{
NBT_Debug("al_init failed???");
return false;
}
ALLEGRO_TIMER *tmr = nullptr;
ALLEGRO_EVENT_QUEUE *queue = nullptr;
ALLEGRO_DISPLAY *dpy = nullptr;
ALLEGRO_BITMAP *bmp = nullptr;
ALLEGRO_TRANSFORM *def_trans = nullptr;
ALLEGRO_FONT *fnt = nullptr;
if(!al_install_keyboard())
goto init_failed;
if(!al_install_mouse())
goto init_failed;
if(!al_init_primitives_addon())
goto init_failed;
if(!al_init_image_addon())
goto init_failed;
if(!al_init_font_addon())
goto init_failed;
tmr = al_create_timer(1.0/60.0);
if(!tmr)
goto init_failed;
queue = al_create_event_queue();
if(!queue)
goto init_failed;
// do display creation last so a display isn't created and instantly destroyed if any of the
// preceeding initializations fail.
al_set_new_display_flags(ALLEGRO_OPENGL | ALLEGRO_PROGRAMMABLE_PIPELINE | ALLEGRO_OPENGL_3_0);
//al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_REQUIRE);
//al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_DEPTH_SIZE, 24, ALLEGRO_REQUIRE);
dpy = al_create_display(800, 600);
if(!dpy)
{
NBT_Debug("display creation failed");
goto init_failed;
}
if(!al_get_opengl_extension_list()->ALLEGRO_GL_EXT_framebuffer_object)
{
NBT_Debug("FBO GL extension is missing. bail");
goto init_failed;
}
glGenVertexArrays(1, &vao_);
glBindVertexArray(vao_);
NBT_Debug("load shaders");
if(!loadShaders("shaders/default.vtx", "shaders/default.pxl"))
{
NBT_Debug("shader init failed");
goto init_failed;
}
NBT_Debug("load allegro shaders");
if(!loadAllegroShaders())
{
NBT_Debug("allegro shader init failed");
goto init_failed;
}
glBindVertexArray(0);
NBT_Debug("create resource manager");
resManager_ = new ResourceManager(this);
if(!resManager_->init(mc, argv0))
{
NBT_Debug("failed to init resource manager");
goto init_failed;
}
fnt = al_create_builtin_font();
if(!fnt)
{
NBT_Debug("failed to create builtin font");
goto init_failed;
}
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_display_event_source(dpy));
al_register_event_source(queue, al_get_timer_event_source(tmr));
def_trans = al_get_projection_transform(dpy);
al_copy_transform(&al_proj_transform_, def_trans);
al_identity_transform(&camera_transform_);
rx_look = 0.0;
queue_ = queue;
tmr_ = tmr;
dpy_ = dpy;
bmp_ = bmp;
fnt_ = fnt;
grab_mouse_ = false;
// initial clear display
// make things look purdy
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
NBT_Debug("end");
return true;
init_failed:
delete resManager_;
resManager_ = nullptr;
if(fnt)
al_destroy_font(fnt);
if(dpy)
al_destroy_display(dpy);
if(queue)
al_destroy_event_queue(queue);
al_uninstall_system();
NBT_Debug("end");
return false;
}
extern int
main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_FONT *font;
bool done = false;
bool redraw = true;
use_constraints = true;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Failed to init Allegro.\n");
}
if (!al_init_primitives_addon()) {
abort_example("Failed to init primitives addon.\n");
}
if (!al_init_image_addon()) {
abort_example("Failed to init image addon.\n");
}
if (!al_init_font_addon()) {
abort_example("Failed to init font addon.\n");
}
if (!al_init_native_dialog_addon()) {
abort_example("Failed to init native dialog addon.\n");
}
al_set_new_display_flags(ALLEGRO_WINDOWED
#if defined(USE_GTK) && !defined(_WIN32)
| ALLEGRO_GTK_TOPLEVEL
#endif
| ALLEGRO_RESIZABLE | ALLEGRO_MAXIMIZED
| ALLEGRO_GENERATE_EXPOSE_EVENTS);
/* creating really small display */
display = al_create_display(DISPLAY_W / 3, DISPLAY_H / 3);
if (!display) {
abort_example("Error creating display.\n");
}
/* set lower limits for constraints only */
if(!al_set_window_constraints(display, DISPLAY_W / 2, DISPLAY_H / 2, 0, 0))
abort_example("Unable to set window constraints.\n");
al_apply_window_constraints(display, use_constraints);
if (!al_install_keyboard()) {
abort_example("Error installing keyboard.\n");
}
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));
ALLEGRO_COLOR color_1 = al_map_rgb(255, 127, 0);
ALLEGRO_COLOR color_2 = al_map_rgb(0, 255, 0);
ALLEGRO_COLOR *color = &color_1;
ALLEGRO_COLOR color_text = al_map_rgb(0, 0, 0);
font = al_create_builtin_font();
while (!done) {
ALLEGRO_EVENT event;
if (redraw && al_is_event_queue_empty(queue)) {
redraw = false;
int x2 = al_get_display_width(display) - 10;
int y2 = al_get_display_height(display) - 10;
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_filled_rectangle(10, 10, x2, y2, *color);
draw_information(display, font, color_text);
al_flip_display();
}
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
done = true;
break;
case ALLEGRO_EVENT_KEY_UP:
if (event.keyboard.keycode == ALLEGRO_KEY_SPACE) {
redraw = true;
if (color == &color_1) {
if (!al_set_window_constraints(display,
0, 0,
DISPLAY_W, DISPLAY_H))
{
abort_example("Unable to set window constraints.\n");
}
color = &color_2;
}
else {
if (!al_set_window_constraints(display,
DISPLAY_W / 2, DISPLAY_H / 2,
0, 0))
{
abort_example("Unable to set window constraints.\n");
}
color = &color_1;
}
al_apply_window_constraints(display, use_constraints);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_ENTER) {
redraw = true;
use_constraints = !use_constraints;
al_apply_window_constraints(display, use_constraints);
}
break;
case ALLEGRO_EVENT_DISPLAY_RESIZE:
al_acknowledge_resize(event.display.source);
redraw = true;
break;
case ALLEGRO_EVENT_DISPLAY_EXPOSE:
redraw = true;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
} /* switch (event.type) { */
}
al_destroy_font(font);
return 0;
}
int main(void) {
ALLEGRO_VERTEX v[8];
ALLEGRO_DISPLAY * display;
ALLEGRO_TRANSFORM perst;
ALLEGRO_TRANSFORM camt;
ALLEGRO_BITMAP * texture, * texture2;
ALLEGRO_EVENT_QUEUE * queue;
ALLEGRO_EVENT event;
ALLEGRO_FONT * font;
int busy = 1;
float cx = 0;
float cy = -2; // 128;
float cz = 0;
int face = 0;
int hori = 0;
float angle = 0;
float theta = 0;
float near = 2;
float far = 8192;
float zoom = 1;
float scale = 1.0;
float us = 20;
float ratio = 480.0 / 640.0;
al_init();
al_init_image_addon();
al_init_font_addon();
al_install_keyboard();
font = al_create_builtin_font();
queue = al_create_event_queue();
al_set_new_display_option(ALLEGRO_DEPTH_SIZE, 16, ALLEGRO_SUGGEST);
display = al_create_display(640, 480);
al_register_event_source(queue, al_get_keyboard_event_source());
texture = al_load_bitmap("tile_1.png");
texture2 = al_load_bitmap("tile_2.png");
/* Allegro coordinates: +Y is down, +X is to the right,
* and +Z comes "out of" the screen.
*
*/
while (busy) {
init_vertex(v+0, 0, 0, 0, 0, 0, 1, 0, 0, 1);
init_vertex(v+1, 0, 0, us, 0, 256, 0, 1, 0, 1);
init_vertex(v+2, us, 0, us, 256, 256, 0, 0, 1, 1);
init_vertex(v+3, us, 0, 0, 256, 0, 1, 1, 0, 1);
init_vertex(v+4, us, -us, 0, 256, 256, 1, 0, 1, 1);
init_vertex(v+5, 0, -us, 0, 256, 0, 0, 1, 1, 1);
init_vertex(v+6, 0, -us, us, 256, 256, 0, 0, 0, 1);
init_vertex(v+7, 0, 0, us, 0, 256, 1, 1, 1, 1);
al_identity_transform(&camt);
al_scale_transform_3d(&camt, scale, scale, scale);
al_translate_transform_3d(&camt, cx, cy, cz);
angle = face * 0.125 * ALLEGRO_PI;
al_rotate_transform_3d(&camt, 0, -1, 0, angle);
theta = hori * 0.125 * ALLEGRO_PI;
al_rotate_transform_3d(&camt, -1, 0, 0, theta);
al_use_transform(&camt);
// al_set_projection_transform(display, &perst);
al_clear_to_color(al_map_rgb_f(0.75, 0.75, 0.95));
al_set_render_state(ALLEGRO_DEPTH_TEST, 1);
al_clear_depth_buffer(far);
al_identity_transform(&perst);
al_perspective_transform(&perst, -1, ratio, near,
1, -ratio, far);
al_use_projection_transform(&perst);
al_draw_filled_rectangle(0, 0, 4, 5, al_map_rgb_f(0, 0.25, 0.25));
al_draw_prim(v, NULL, texture, 0, 8, ALLEGRO_PRIM_TRIANGLE_FAN);
draw_textured_colored_rectangle_3d(0 , -us, 0, us, us, 0,
1.0, 1.0, texture2, al_map_rgb_f(1,1,1));
draw_textured_colored_rectangle_3d(0 , -us, 0, 0, us, us,
1.0, 1.0, texture2, al_map_rgb_f(1,1,1));
draw_textured_colored_rectangle_3d(0 , 0, 0, us, 0, us,
1.0, 1.0, texture2, al_map_rgb_f(1,1,1));
al_identity_transform(&perst);
al_orthographic_transform(&perst, 0, 0, -1.0, 640, 480, 1.0);
al_identity_transform(&camt);
al_use_projection_transform(&perst);
al_use_transform(&camt);
al_draw_filled_rectangle(111, 22, 133, 44, al_map_rgb_f(0.25, 0.25, 0));
al_draw_multiline_textf(font, al_map_rgb_f(1,1,1), 10, 10, 620, 0, 0,
"Coords: (%f %f %f)\nAngle: (%f %f)\nView: [%f %f %f %f]\nScale: %f",
cx, cy, cz, angle, theta, near, far, zoom, scale);
al_flip_display();
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
switch (event.keyboard.keycode) {
case ALLEGRO_KEY_RIGHT:
cx += 8;
break;
case ALLEGRO_KEY_LEFT:
cx -= 8;
break;
case ALLEGRO_KEY_UP:
cy += 8;
break;
case ALLEGRO_KEY_DOWN:
cy -= 8;
break;
case ALLEGRO_KEY_HOME:
cz += 8;
break;
case ALLEGRO_KEY_END:
cz -= 8;
break;
case ALLEGRO_KEY_R:
face++;
break;
case ALLEGRO_KEY_L:
face--;
break;
case ALLEGRO_KEY_H:
hori++;
break;
case ALLEGRO_KEY_G:
hori--;
break;
case ALLEGRO_KEY_N:
near *= 2.0;
break;
case ALLEGRO_KEY_M:
near /= 2.0;
break;
case ALLEGRO_KEY_F:
far += 64;
break;
case ALLEGRO_KEY_V:
far -= 64;
break;
case ALLEGRO_KEY_Z:
zoom *= 2.0f;
break;
case ALLEGRO_KEY_S:
zoom /= 2.0f;
break;
case ALLEGRO_KEY_A:
scale *= 2.0f;
break;
case ALLEGRO_KEY_Q:
scale /= 2.0f;
break;
case ALLEGRO_KEY_ESCAPE:
busy = 0 ;
break;
default:
break;
}
}
}
al_destroy_bitmap(texture);
al_destroy_bitmap(texture2);
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_MONITOR_INFO info;
const char* bitmap_filename;
int w = 640, h = 480;
bool done = false;
bool need_redraw = true;
bool background = false;
example.show_help = true;
example.hold_bitmap_drawing = false;
if (argc > 1) {
bitmap_filename = argv[1];
}
else {
bitmap_filename = "data/mysha256x256.png";
}
if (!al_init()) {
abort_example("Failed to init Allegro.\n");
}
if (!al_init_image_addon()) {
abort_example("Failed to init IIO addon.\n");
}
al_init_font_addon();
init_platform_specific();
al_get_num_video_adapters();
al_get_monitor_info(0, &info);
al_set_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS,
ALLEGRO_DISPLAY_ORIENTATION_ALL, ALLEGRO_SUGGEST);
example.display = al_create_display(w, h);
if (!example.display) {
abort_example("Error creating display.\n");
}
w = al_get_display_width(example.display);
h = al_get_display_height(example.display);
if (!al_install_keyboard()) {
abort_example("Error installing keyboard.\n");
}
if (!al_install_mouse()) {
abort_example("Error installing mouse.\n");
}
al_install_touch_input();
example.font = al_create_builtin_font();
if (!example.font) {
abort_example("Error creating builtin font\n");
}
example.mysha = al_load_bitmap(bitmap_filename);
if (!example.mysha) {
abort_example("Error loading %s\n", bitmap_filename);
}
example.white = al_map_rgb_f(1, 1, 1);
example.half_white = al_map_rgba_f(1, 1, 1, 0.5);
example.dark = al_map_rgb(15, 15, 15);
example.red = al_map_rgb_f(1, 0.2, 0.1);
change_size(256);
add_sprite();
add_sprite();
timer = al_create_timer(1.0 / FPS);
queue = al_create_event_queue();
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));
if (al_install_touch_input())
al_register_event_source(queue, al_get_touch_input_event_source());
al_register_event_source(queue, al_get_display_event_source(example.display));
al_start_timer(timer);
while (!done) {
float x, y;
ALLEGRO_EVENT event;
w = al_get_display_width(example.display);
h = al_get_display_height(example.display);
if (!background && need_redraw && al_is_event_queue_empty(queue)) {
double t = -al_get_time();
add_time();
al_clear_to_color(al_map_rgb_f(0, 0, 0));
redraw();
t += al_get_time();
example.direct_speed_measure = t;
al_flip_display();
need_redraw = false;
}
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_KEY_CHAR: /* includes repeats */
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
done = true;
else if (event.keyboard.keycode == ALLEGRO_KEY_UP) {
add_sprites(1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_DOWN) {
remove_sprites(1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_LEFT) {
change_size(example.bitmap_size - 1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_RIGHT) {
change_size(example.bitmap_size + 1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_F1) {
example.show_help ^= 1;
}
else if (event.keyboard.keycode == ALLEGRO_KEY_SPACE) {
example.use_memory_bitmaps ^= 1;
change_size(example.bitmap_size);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_B) {
example.blending++;
if (example.blending == 5)
example.blending = 0;
}
else if (event.keyboard.keycode == ALLEGRO_KEY_H) {
example.hold_bitmap_drawing ^= 1;
}
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
case ALLEGRO_EVENT_DISPLAY_HALT_DRAWING:
background = true;
al_acknowledge_drawing_halt(event.display.source);
break;
case ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING:
background = false;
al_acknowledge_drawing_resume(event.display.source);
break;
case ALLEGRO_EVENT_DISPLAY_RESIZE:
al_acknowledge_resize(event.display.source);
break;
case ALLEGRO_EVENT_TIMER:
update();
need_redraw = true;
break;
case ALLEGRO_EVENT_TOUCH_BEGIN:
x = event.touch.x;
y = event.touch.y;
goto click;
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
x = event.mouse.x;
y = event.mouse.y;
goto click;
click:
{
int fh = al_get_font_line_height(example.font);
if (x < fh * 12 && y >= h - fh * 30) {
int button = (y - (h - fh * 30)) / (fh * 6);
if (button == 0) {
example.use_memory_bitmaps ^= 1;
change_size(example.bitmap_size);
}
if (button == 1) {
example.blending++;
if (example.blending == 5)
example.blending = 0;
}
if (button == 3) {
if (x < fh * 6)
remove_sprites(example.sprite_count / 2);
else
add_sprites(example.sprite_count);
}
if (button == 2) {
int s = example.bitmap_size * 2;
if (x < fh * 6)
s = example.bitmap_size / 2;
change_size(s);
}
if (button == 4) {
example.show_help ^= 1;
}
}
break;
}
}
}
al_destroy_bitmap(example.bitmap);
return 0;
}
int main(int argc, char **argv)
{
InitAllegro();
ALLEGRO_KEYBOARD_STATE klawiatura;
ALLEGRO_MOUSE_STATE mysz;
ALLEGRO_EVENT_QUEUE* event_queue = al_create_event_queue();
ALLEGRO_EVENT_QUEUE* key_queue = al_create_event_queue();
ALLEGRO_DISPLAY* okno = al_create_display(WINDOW_WIDTH, WINDOW_HEIGHT);
ALLEGRO_FONT* defaultFont = al_create_builtin_font();
ALLEGRO_TIMER* timer = al_create_timer(1.0 / 60.0);
al_register_event_source(key_queue, al_get_display_event_source(okno));
al_register_event_source(event_queue, al_get_display_event_source(okno));
al_register_event_source(key_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_set_window_title(okno, "Fraktale");
al_set_target_bitmap(al_get_backbuffer(okno));
Menu* menu = new Menu(WINDOW_WIDTH, WINDOW_HEIGHT);
Mandelbrot* mandelbrot = new Mandelbrot(WINDOW_WIDTH, WINDOW_HEIGHT, defaultFont);
Julia* julia = new Julia(WINDOW_WIDTH, WINDOW_HEIGHT, defaultFont);
Window* window = new Window(menu, mandelbrot, julia);
menu->SetWindow(window);
mandelbrot->SetWindow(window);
julia->SetWindow(window);
const ALLEGRO_COLOR backgroundColor = al_map_rgb(255, 255, 255);
const ALLEGRO_COLOR frameColor = al_map_rgb(255, 255, 255);
const int frameThickness = 2;
ALLEGRO_USTR* str = al_ustr_new("");
int pos = (int)al_ustr_size(str);
ALLEGRO_EVENT ev;
double blokadaKlikniecia = al_get_time();
int poczX = -1, poczY = -1, poprzedniStan = window->stanOkna;
bool petla = true, klikniecieMyszy = false, klawiszWcisniety = false, wpisywanieIteracji = false;
double screenRatio = static_cast<double>(WINDOW_HEIGHT) / static_cast<double>(WINDOW_WIDTH);
while (petla)
{
if (poprzedniStan != window->stanOkna)
{
blokadaKlikniecia = al_get_time();
}
poprzedniStan = window->stanOkna;
al_get_next_event(event_queue, &ev);
al_get_mouse_state(&mysz);
int mx = mysz.x;
int my = mysz.y;
bool koniecKlikniecia = false;
if (mysz.buttons & 1 && klikniecieMyszy == false && al_get_time() > blokadaKlikniecia + 0.3)
{
klikniecieMyszy = true;
if (window->CzyFraktal())
{
poczX = mx;
poczY = my;
}
}
else if (!(mysz.buttons & 1) && klikniecieMyszy == true && al_get_time() > blokadaKlikniecia + 0.3)
{
klikniecieMyszy = false;
int pp = window->stanOkna;
int respond = window->Click(mx, my);
if (respond == Responds_t::RESPOND_CLOSE_WINDOW)
petla = false;
if (window->CzyFraktal() && (pp == WINDOWSTATE_MANDELBROT || pp == WINDOWSTATE_JULIA))
{
koniecKlikniecia = true;
}
if (pp == WINDOWSTATE_MENU && window->CzyFraktal())
{
window->ZaladujFraktal();
}
}
if (koniecKlikniecia)
{
if (window->CzyFraktal())
{
Fraktal* fraktal = window->AktualnyFraktal();
fraktal->Powieksz(poczX, mx, poczY, SkalujY(poczY, screenRatio, poczX, mx));
}
poczX = -1, poczY = -1;
}
al_get_next_event(key_queue, &ev);
if (ev.type == ALLEGRO_EVENT_KEY_DOWN && klawiszWcisniety == false && window->CzyFraktal())
{
int kod = ev.keyboard.keycode;
klawiszWcisniety = true;
if (kod == 9)
{
wpisywanieIteracji = true;
}
else if (kod == 10)
{
Fraktal* fraktal = window->AktualnyFraktal();
fraktal->Resetuj();
}
else if (kod >= 27 && kod <= 36 && wpisywanieIteracji)
{
pos += al_ustr_append_chr(str, kod + 21);
}
else if (kod == ALLEGRO_KEY_ENTER)
{
if (wpisywanieIteracji == true)
wpisywanieIteracji = false;
unsigned char* tmp = str->data;
int t = atoi((const char*)tmp);
window->SetIteracje(t);
}
else if (kod == ALLEGRO_KEY_BACKSPACE)
{
if (al_ustr_prev(str, &pos))
al_ustr_truncate(str, pos);
}
else if (kod == ALLEGRO_KEY_ESCAPE)
{
window->stanOkna = WINDOWSTATE_MENU;
}
}
else if (ev.type == ALLEGRO_EVENT_KEY_UP)
{
klawiszWcisniety = false;
}
al_clear_to_color(backgroundColor);
if (wpisywanieIteracji)
window->Draw(str);
else
window->Draw(NULL);
if(poczX != -1)
al_draw_rectangle(poczX, poczY, mx, SkalujY(poczY, screenRatio, poczX, mx), frameColor, frameThickness);
al_flip_display();
}
al_destroy_display(okno);
return 0;
}
int engine_init(struct Engine_Conf *conf)
{
if (engine.initialized)
{
return 1;
}
// Initialize Allegro and stuff
al_init();
if (!al_install_keyboard())
{
puts("engine_init(): Failed to initialize the keyboard...");
return 0;
}
if (!al_install_mouse())
{
puts("engine_init(): Failed to initialize the mouse...");
return 0;
}
if (al_install_audio())
{
if (!al_init_acodec_addon())
{
puts("engine_init(): Failed to initialize codecs...");
}
al_reserve_samples(1);
}
else
{
puts("engine_init(): Failed to initialize audio...");
}
// Add-ons
if (!al_init_image_addon())
{
puts("engine_init(): Failed to initialize image addon...");
return 0;
}
al_init_font_addon();
al_init_primitives_addon();
if (conf->fullscreen)
{
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
}
// Initialize variables...
engine.display = al_create_display(conf->width, conf->height);
if (!engine.display)
{
puts("engine_init(): Failed to create a display window...");
return 0;
}
al_set_window_title(engine.display, conf->title);
MAINCONF = conf;
aspect_ratio_transform();
al_add_new_bitmap_flag(ALLEGRO_MAG_LINEAR);
if (conf->buffer)
{
engine.buffer = al_create_bitmap(conf->width, conf->height);
al_set_new_bitmap_flags(0);
}
font = al_create_builtin_font();
engine.timer = al_create_timer(1.0 / conf->framerate);
engine.event_queue = al_create_event_queue();
engine.sm.change_state = change_state;
engine.sm.push_state = push_state;
engine.sm.pop_state = pop_state;
set_bg_color(al_map_rgb(192, 192, 192));
srand(time(NULL));
engine.initialized = TRUE;
return 1;
}
int engine_init(struct Engine_Conf *conf)
{
if (engine.initialized)
{
puts("WARNING: Calling game_init() more than once");
return 1;
}
// Initialize Allegro and stuff
al_init();
if (!al_install_keyboard())
{
puts("ERROR: Could not initialize the keyboard...");
return 0;
}
if (conf->audio)
{
if (!al_install_audio())
{
puts("ERROR: Could not initialize audio...");
return 0;
}
if (!al_init_acodec_addon())
{
puts("ERROR: Could not initialize acodec addon...");
return 0;
}
}
// Add-ons
if (!al_init_image_addon())
{
puts("ERROR: Could not initialize image addon...");
return 0;
}
al_init_font_addon();
al_init_primitives_addon();
// Find how much the game will be scaled when conf->scale <= 0
if (conf->scale <= 0)
{
ALLEGRO_MONITOR_INFO info;
al_get_monitor_info(0, &info);
int monitor_w = info.x2 - info.x1;
int monitor_h = info.y2 - info.y1;
float new_monitor_w = (monitor_w - (monitor_w * SCREEN_RES_OVERRIDE));
float new_monitor_h = (monitor_h - (monitor_h * SCREEN_RES_OVERRIDE));
conf->scale = 2;
// Keep scaling until a suitable scale factor is found
while (1)
{
int scale_w = conf->width * conf->scale;
int scale_h = conf->height * conf->scale;
if (scale_w > new_monitor_w || scale_h > new_monitor_h)
{
--conf->scale;
break;
}
++conf->scale;
}
}
else if (conf->scale < 2)
{
conf->scale = 2;
}
engine.display = al_create_display(conf->width * conf->scale,
conf->height * conf->scale);
if (!engine.display)
{
puts("ERROR: Could not create a display window...");
return 0;
}
al_set_window_title(engine.display, conf->title);
font = al_create_builtin_font();
engine.timer = al_create_timer(1.0 / conf->framerate);
engine.event_queue = al_create_event_queue();
mainconf = conf;
set_bg_color(BG_COLOR_DEFAULT);
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_scale_transform(&trans, conf->scale, conf->scale);
al_use_transform(&trans);
engine.initialized = TRUE;
return 1;
}
int main(void)
{
ALLEGRO_TRANSFORM trans;
ALLEGRO_EVENT event;
int bps = 4;
bool redraw = false;
unsigned int last_timer = 0;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log();
al_install_keyboard();
display = al_create_display(640, 480);
if (!display) {
abort_example("Could not create display\n");
}
font = al_create_builtin_font();
if (!font) {
abort_example("Could not create font\n");
}
if (!al_install_audio()) {
abort_example("Could not init sound\n");
}
if (!al_reserve_samples(RESERVED_SAMPLES)) {
abort_example("Could not set up voice and mixer\n");
}
ping = generate_ping();
if (!ping) {
abort_example("Could not generate sample\n");
}
timer = al_create_timer(1.0 / bps);
al_set_timer_count(timer, -1);
event_queue = al_create_event_queue();
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_identity_transform(&trans);
al_scale_transform(&trans, 16.0, 16.0);
al_use_transform(&trans);
al_start_timer(timer);
while (true) {
al_wait_for_event(event_queue, &event);
if (event.type == ALLEGRO_EVENT_TIMER) {
const float speed = pow(21.0/20.0, (event.timer.count % PERIOD));
if (!al_play_sample(ping, 1.0, 0.0, speed, ALLEGRO_PLAYMODE_ONCE, NULL)) {
log_printf("Not enough reserved samples.\n");
}
redraw = true;
last_timer = event.timer.count;
}
else if (event.type == ALLEGRO_EVENT_KEY_CHAR) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
break;
}
if (event.keyboard.unichar == '+' || event.keyboard.unichar == '=') {
if (bps < 32) {
bps++;
al_set_timer_speed(timer, 1.0 / bps);
}
}
else if (event.keyboard.unichar == '-') {
if (bps > 1) {
bps--;
al_set_timer_speed(timer, 1.0 / bps);
}
}
}
if (redraw && al_is_event_queue_empty(event_queue)) {
ALLEGRO_COLOR c;
if (last_timer % PERIOD == 0)
c = al_map_rgb_f(1, 1, 1);
else
c = al_map_rgb_f(0.5, 0.5, 1.0);
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_textf(font, c, 640/32, 480/32 - 4, ALLEGRO_ALIGN_CENTRE,
"%u", last_timer);
al_flip_display();
}
}
close_log(false);
return 0;
}