/* Function: al_set_path_drive
*/
void al_set_path_drive(ALLEGRO_PATH *path, const char *drive)
{
ASSERT(path);
if (drive)
al_ustr_assign_cstr(path->drive, drive);
else
al_ustr_truncate(path->drive, 0);
}
/* Function: al_set_path_filename
*/
void al_set_path_filename(ALLEGRO_PATH *path, const char *filename)
{
ASSERT(path);
if (filename)
al_ustr_assign_cstr(path->filename, filename);
else
al_ustr_truncate(path->filename, 0);
}
/* Test al_ustr_truncate. */
static void t14(void)
{
ALLEGRO_USTR *us1 = al_ustr_new("aábdðeéfghiíjkprstuúvxyýþæö");
/* Truncate from middle of string. */
CHECK(al_ustr_truncate(us1, 30));
CHECK(0 == strcmp(al_cstr(us1), "aábdðeéfghiíjkprstuúvxyý"));
/* Truncate past end (allowed). */
CHECK(al_ustr_truncate(us1, 100));
CHECK(0 == strcmp(al_cstr(us1), "aábdðeéfghiíjkprstuúvxyý"));
/* Truncate before start (not allowed). */
CHECK(! al_ustr_truncate(us1, -1));
CHECK(0 == strcmp(al_cstr(us1), "aábdðeéfghiíjkprstuúvxyý"));
al_ustr_free(us1);
}
/* Function: al_set_path_extension
*/
bool al_set_path_extension(ALLEGRO_PATH *path, char const *extension)
{
int dot;
ASSERT(path);
if (al_ustr_size(path->filename) == 0) {
return false;
}
dot = al_ustr_rfind_chr(path->filename, al_ustr_size(path->filename), '.');
if (dot >= 0) {
al_ustr_truncate(path->filename, dot);
}
al_ustr_append_cstr(path->filename, extension);
return true;
}
static bool glsl_build_shader(ALLEGRO_SHADER *shader)
{
GLint status;
ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
GLchar error_buf[4096];
if (gl_shader->vertex_shader == 0 && gl_shader->pixel_shader == 0)
return false;
if (gl_shader->program_object != 0) {
glDeleteProgram(gl_shader->program_object);
}
gl_shader->program_object = glCreateProgram();
if (gl_shader->program_object == 0)
return false;
if (gl_shader->vertex_shader)
glAttachShader(gl_shader->program_object, gl_shader->vertex_shader);
if (gl_shader->pixel_shader)
glAttachShader(gl_shader->program_object, gl_shader->pixel_shader);
glLinkProgram(gl_shader->program_object);
glGetProgramiv(gl_shader->program_object, GL_LINK_STATUS, &status);
if (status == 0) {
glGetProgramInfoLog(gl_shader->program_object, sizeof(error_buf), NULL,
error_buf);
if (shader->log) {
al_ustr_truncate(shader->log, 0);
al_ustr_append_cstr(shader->log, error_buf);
}
else {
shader->log = al_ustr_new(error_buf);
}
ALLEGRO_ERROR("Link error: %s\n", error_buf);
glDeleteProgram(gl_shader->program_object);
return false;
}
/* Look up variable locations. */
lookup_varlocs(&gl_shader->varlocs, gl_shader->program_object);
return true;
}
/* Output message to ANSI log. */
static void wlog_do_append_native_text_log_ansi(ALLEGRO_NATIVE_DIALOG *textlog)
{
int index;
CHARFORMATA format;
memset(&format, 0, sizeof(format));
format.cbSize = sizeof(format);
format.dwMask = CFM_COLOR;
format.crTextColor = RGB(128, 255, 128);
index = GetWindowTextLength(textlog->tl_textview);
SendMessageA(textlog->tl_textview, EM_SETSEL, (WPARAM)index, (LPARAM)index);
SendMessageA(textlog->tl_textview, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&format);
SendMessageA(textlog->tl_textview, EM_REPLACESEL, 0, (LPARAM)al_cstr(textlog->tl_pending_text));
al_ustr_truncate(textlog->tl_pending_text, 0);
textlog->tl_have_pending = false;
}
static bool ljoy_detect_device_name(int num, ALLEGRO_USTR *device_name)
{
char key[80];
const char *value;
struct stat stbuf;
al_ustr_truncate(device_name, 0);
snprintf(key, sizeof(key), "device%d", num);
value = al_get_config_value(al_get_system_config(), "joystick", key);
if (value)
al_ustr_assign_cstr(device_name, value);
if (al_ustr_size(device_name) == 0)
al_ustr_appendf(device_name, "/dev/input/event%d", num);
return (stat(al_cstr(device_name), &stbuf) == 0);
}
/* Output message to Unicode log. */
static void wlog_do_append_native_text_log_unicode(ALLEGRO_NATIVE_DIALOG *textlog)
{
#define BUFFER_SIZE 512
bool flush;
int index, ch, next;
static WCHAR buffer[BUFFER_SIZE + 1] = { 0 };
CHARFORMATW format;
memset(&format, 0, sizeof(format));
format.cbSize = sizeof(format);
format.dwMask = CFM_COLOR;
format.crTextColor = RGB(128, 255, 128);
index = GetWindowTextLength(textlog->tl_textview);
SendMessageW(textlog->tl_textview, EM_SETSEL, (WPARAM)index, (LPARAM)index);
SendMessageW(textlog->tl_textview, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&format);
next = 0;
index = 0;
flush = false;
while ((ch = al_ustr_get_next(textlog->tl_pending_text, &next)) >= 0) {
buffer[index] = (WCHAR)ch;
flush = true;
index++;
if ((index % BUFFER_SIZE) == 0) {
buffer[BUFFER_SIZE] = L'\0';
SendMessageW(textlog->tl_textview, EM_REPLACESEL, 0, (LPARAM)buffer);
flush = false;
index = 0;
}
}
if (flush) {
buffer[index] = L'\0';
SendMessageW(textlog->tl_textview, EM_REPLACESEL, 0, (LPARAM)buffer);
}
al_ustr_truncate(textlog->tl_pending_text, 0);
textlog->tl_have_pending = false;
}
/* Function: al_is_path_present
*/
bool al_is_path_present(const ALLEGRO_PATH *path)
{
ALLEGRO_USTR *ustr;
bool rc;
ASSERT(path);
ustr = al_ustr_new("");
path_to_ustr(path, ALLEGRO_NATIVE_PATH_SEP, ustr);
/* Windows' stat() doesn't like the slash at the end of the path when
* the path is pointing to a directory. There are other places which
* might require the same fix.
*/
#ifdef ALLEGRO_WINDOWS
if (al_ustr_has_suffix_cstr(ustr, "\\")) {
al_ustr_truncate(ustr, al_ustr_size(ustr) - 1);
}
#endif
rc = al_filename_exists(al_cstr(ustr));
al_ustr_free(ustr);
return rc;
}
/* [gtk thread] */
static gboolean do_append_native_text_log(gpointer data)
{
ALLEGRO_NATIVE_DIALOG *textlog = data;
al_lock_mutex(textlog->tl_text_mutex);
GtkTextView *tv = GTK_TEXT_VIEW(textlog->tl_textview);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(tv);
GtkTextIter iter;
GtkTextMark *mark;
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert(buffer, &iter, al_cstr(textlog->tl_pending_text), -1);
mark = gtk_text_buffer_create_mark(buffer, NULL, &iter, FALSE);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(textlog->tl_textview), mark);
gtk_text_buffer_delete_mark(buffer, mark);
al_ustr_truncate(textlog->tl_pending_text, 0);
textlog->tl_have_pending = false;
al_unlock_mutex(textlog->tl_text_mutex);
return FALSE;
}
static bool glsl_attach_shader_source(ALLEGRO_SHADER *shader,
ALLEGRO_SHADER_TYPE type, const char *source)
{
GLint status;
GLchar error_buf[4096];
ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
ALLEGRO_DISPLAY *display = al_get_current_display();
ASSERT(display);
ASSERT(display->flags & ALLEGRO_OPENGL);
if (source == NULL) {
if (type == ALLEGRO_VERTEX_SHADER) {
if (gl_shader->vertex_shader) {
glDetachShader(gl_shader->program_object, gl_shader->vertex_shader);
glDeleteShader(gl_shader->vertex_shader);
gl_shader->vertex_shader = 0;
}
}
else {
if (gl_shader->pixel_shader) {
glDetachShader(gl_shader->program_object, gl_shader->pixel_shader);
glDeleteShader(gl_shader->pixel_shader);
gl_shader->pixel_shader = 0;
}
}
return true;
}
else {
GLuint *handle;
GLenum gl_type;
if (type == ALLEGRO_VERTEX_SHADER) {
handle = &(gl_shader->vertex_shader);
gl_type = GL_VERTEX_SHADER;
}
else {
handle = &(gl_shader->pixel_shader);
gl_type = GL_FRAGMENT_SHADER;
}
*handle = glCreateShader(gl_type);
if ((*handle) == 0) {
return false;
}
glShaderSource(*handle, 1, &source, NULL);
glCompileShader(*handle);
glGetShaderiv(*handle, GL_COMPILE_STATUS, &status);
if (status == 0) {
glGetShaderInfoLog(*handle, sizeof(error_buf), NULL, error_buf);
if (shader->log) {
al_ustr_truncate(shader->log, 0);
al_ustr_append_cstr(shader->log, error_buf);
}
else {
shader->log = al_ustr_new(error_buf);
}
ALLEGRO_ERROR("Compile error: %s\n", error_buf);
glDeleteShader(*handle);
return false;
}
}
return true;
}
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;
}
