omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

App::I static singleton to pointer

Browse Source
This commit is contained in:
omigamedev
2019-07-11 18:08:17 +02:00
parent 92dd00d910
commit b89274e7a6
33 changed files with 417 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
android/src/cpp/main.cpp
View File

@@ -255,19 +255,21 @@ JNIEXPORT void JNICALL Java_com_omixlab_panopainter_MainActivity_pickExternalCal
env->ReleaseStringUTFChars(path, path_utf); env->ReleaseStringUTFChars(path, path_utf);
LOG("data_path %s", file_path.c_str()); LOG("data_path %s", file_path.c_str());
App::I.data_path = file_path; App::I->data_path = file_path;
App::I.work_path = file_path; App::I->work_path = file_path;
App::I.rec_path = file_path + "/frames"; App::I->rec_path = file_path + "/frames";
App::I->initLog();
} }
JNIEXPORT void JNICALL Java_com_omixlab_panopainter_MainActivity_contentRectChanged(JNIEnv *end, jobject, JNIEXPORT void JNICALL Java_com_omixlab_panopainter_MainActivity_contentRectChanged(JNIEnv *end, jobject,
jint wnd_w, jint wnd_h, jint rect_left, jint rect_top, jint rect_right, jint rect_bottom) jint wnd_w, jint wnd_h, jint rect_left, jint rect_top, jint rect_right, jint rect_bottom)
{ {
#ifndef __QUEST__ #ifndef __QUEST__
LOG("resize wnd [%d %d] rect [%d %d %d %d]", wnd_w, wnd_h, rect_left, rect_top, rect_right, rect_bottom); LOG("resize wnd [%d %d] rect [%d %d %d %d]", wnd_w, wnd_h, rect_left, rect_top, rect_right, rect_bottom);
App::I.width = wnd_w; App::I->width = wnd_w;
App::I.height = (rect_bottom - rect_top); App::I->height = (rect_bottom - rect_top);
App::I.off_x = 0; App::I->off_x = 0;
App::I.off_y = wnd_h - (rect_bottom - rect_top); App::I->off_y = wnd_h - (rect_bottom - rect_top);
#endif #endif
} }
} }
@@ -315,7 +317,6 @@ std::string get_data_path(android_app* mApplication)
*/ */
static int engine_init_display(struct engine* engine) { static int engine_init_display(struct engine* engine) {
// initialize OpenGL ES and EGL // initialize OpenGL ES and EGL
App::I.initLog();
/* /*
* Here specify the attributes of the desired configuration. * Here specify the attributes of the desired configuration.
@@ -499,7 +500,7 @@ static int engine_init_display(struct engine* engine) {
if (resuming_context) if (resuming_context)
{ {
LOG("RESUME APP"); LOG("RESUME APP");
App::I.and_app = engine->app; App::I->and_app = engine->app;
return 0; return 0;
} }
@@ -593,42 +594,42 @@ static int engine_init_display(struct engine* engine) {
LOG("PROP Mode: %s", os_props["ro.product.model"].c_str()); LOG("PROP Mode: %s", os_props["ro.product.model"].c_str());
Asset::m_am = engine->app->activity->assetManager; Asset::m_am = engine->app->activity->assetManager;
App::I.and_app = engine->app; App::I->and_app = engine->app;
App::I.and_engine = engine; App::I->and_engine = engine;
//std::string base_path = engine->app->activity->externalDataPath ? //std::string base_path = engine->app->activity->externalDataPath ?
// engine->app->activity->externalDataPath : get_data_path(engine->app); // engine->app->activity->externalDataPath : get_data_path(engine->app);
if (App::I.data_path.empty() || App::I.data_path == ".") if (App::I->data_path.empty() || App::I->data_path == ".")
App::I.data_path = get_data_path(engine->app); App::I->data_path = get_data_path(engine->app);
LOG("data_path %s", App::I.data_path.c_str()); LOG("data_path %s", App::I->data_path.c_str());
#ifdef __QUEST__ #ifdef __QUEST__
App::I.zoom = 1.f; App::I->zoom = 1.f;
App::I.width = 1024; App::I->width = 1024;
App::I.height = 1024; App::I->height = 1024;
App::I.redraw = true; App::I->redraw = true;
App::I.init(); App::I->init();
App::I.resize(1024, 1024); App::I->resize(1024, 1024);
App::I.vr_active = true; App::I->vr_active = true;
App::I.has_vr = true; App::I->has_vr = true;
App::I.vr_only = true; App::I->vr_only = true;
#else #else
float density = get_display_density(engine->app); float density = get_display_density(engine->app);
LOG("density %f", density); LOG("density %f", density);
App::I.zoom = density;// / 1.5; App::I->zoom = density;// / 1.5;
App::I.width = w; App::I->width = w;
App::I.height = h; App::I->height = h;
App::I.redraw = true; App::I->redraw = true;
// give control to the render thread // give control to the render thread
LOG("release egl context"); LOG("release egl context");
eglMakeCurrent(engine->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglMakeCurrent(engine->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
LOG("start render threads"); LOG("start render threads");
App::I.render_thread_start(); App::I->render_thread_start();
LOG("start ui thread"); LOG("start ui thread");
App::I.ui_thread_start(); App::I->ui_thread_start();
#endif #endif
return 0; return 0;
} }
@@ -652,7 +653,7 @@ static void engine_draw_frame(struct engine* engine) {
start = now; start = now;
elapsed += dt.count(); elapsed += dt.count();
elapsed_1s += dt.count(); elapsed_1s += dt.count();
App::I.tick(dt.count()); App::I->tick(dt.count());
if (elapsed_1s > 1.f) if (elapsed_1s > 1.f)
{ {
@@ -668,14 +669,14 @@ static void engine_draw_frame(struct engine* engine) {
rendered_frames++; rendered_frames++;
#ifdef __QUEST__ #ifdef __QUEST__
App::I.update(elapsed); App::I->update(elapsed);
oculus_draw(dt.count()); oculus_draw(dt.count());
#else #else
if (!(App::I.redraw || App::I.animate)) if (!(App::I->redraw || App::I->animate))
return; return;
App::I.clear(); App::I->clear();
App::I.update(elapsed); App::I->update(elapsed);
eglSwapBuffers(engine->display, engine->surface); eglSwapBuffers(engine->display, engine->surface);
#endif #endif
@@ -714,7 +715,7 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
//LOG("event type: %d", eventType); //LOG("event type: %d", eventType);
//locker _locker{engine}; //locker _locker{engine};
App::I.redraw = true; App::I->redraw = true;
switch (eventType) { switch (eventType) {
case AINPUT_EVENT_TYPE_MOTION: case AINPUT_EVENT_TYPE_MOTION:
@@ -763,8 +764,8 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
float pressure = AMotionEvent_getPressure(event, 0); float pressure = AMotionEvent_getPressure(event, 0);
kEventSource source = tool_type == AMOTION_EVENT_TOOL_TYPE_STYLUS ? kEventSource source = tool_type == AMOTION_EVENT_TOOL_TYPE_STYLUS ?
kEventSource::Stylus : kEventSource::Touch; kEventSource::Stylus : kEventSource::Touch;
App::I.ui_task_async([=]{ App::I->ui_task_async([=]{
App::I.mouse_down(0, x, y, pressure, source, 0); App::I->mouse_down(0, x, y, pressure, source, 0);
}); });
tracked = 1; tracked = 1;
//LOG("first down"); //LOG("first down");
@@ -783,10 +784,10 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
p0.pos.x = AMotionEvent_getX(event, 0); p0.pos.x = AMotionEvent_getX(event, 0);
p0.pos.y = AMotionEvent_getY(event, 0); p0.pos.y = AMotionEvent_getY(event, 0);
//LOG("second down"); //LOG("second down");
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
if (tracked == 1) if (tracked == 1)
App::I.mouse_cancel(0); App::I->mouse_cancel(0);
App::I.gesture_start(p0.pos, p1.pos); App::I->gesture_start(p0.pos, p1.pos);
}); });
tracked = 2; tracked = 2;
} }
@@ -804,8 +805,8 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
kEventSource::Stylus : kEventSource::Touch; kEventSource::Stylus : kEventSource::Touch;
if (tracked == 1) if (tracked == 1)
{ {
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
App::I.mouse_up(0, x, y, source, 0); App::I->mouse_up(0, x, y, source, 0);
}); });
} }
tracked = 0; tracked = 0;
@@ -817,8 +818,8 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
{ {
p1.id = -1; p1.id = -1;
//LOG("second up"); //LOG("second up");
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
App::I.gesture_end(); App::I->gesture_end();
}); });
} }
return 1; return 1;
@@ -826,8 +827,8 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
{ {
float y = AMotionEvent_getY(event, 0); float y = AMotionEvent_getY(event, 0);
float x = AMotionEvent_getX(event, 0); float x = AMotionEvent_getX(event, 0);
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
App::I.mouse_move(x, y, 0, kEventSource::Stylus, 0); App::I->mouse_move(x, y, 0, kEventSource::Stylus, 0);
}); });
//LOG("single move"); //LOG("single move");
return 1; return 1;
@@ -841,8 +842,8 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
float pressure = AMotionEvent_getPressure(event, 0); float pressure = AMotionEvent_getPressure(event, 0);
kEventSource source = tool_type == AMOTION_EVENT_TOOL_TYPE_STYLUS ? kEventSource source = tool_type == AMOTION_EVENT_TOOL_TYPE_STYLUS ?
kEventSource::Stylus : kEventSource::Touch; kEventSource::Stylus : kEventSource::Touch;
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
App::I.mouse_move(x, y, pressure, source, 0); App::I->mouse_move(x, y, pressure, source, 0);
}); });
//LOG("single move"); //LOG("single move");
} }
@@ -864,8 +865,8 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
float y = AMotionEvent_getY(event, 1); float y = AMotionEvent_getY(event, 1);
p1.pos = {x, y}; p1.pos = {x, y};
} }
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
App::I.gesture_move(p0.pos, p1.pos); App::I->gesture_move(p0.pos, p1.pos);
}); });
} }
return 1; return 1;
@@ -889,22 +890,22 @@ static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
case AKEY_EVENT_ACTION_MULTIPLE: case AKEY_EVENT_ACTION_MULTIPLE:
LOG("Received key multi event: %d\n", key_val); LOG("Received key multi event: %d\n", key_val);
if (uniValue > 32 && uniValue < 127) //printable ascii range if (uniValue > 32 && uniValue < 127) //printable ascii range
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
App::I.key_char(uniValue); App::I->key_char(uniValue);
}); });
break; break;
case AKEY_EVENT_ACTION_DOWN: case AKEY_EVENT_ACTION_DOWN:
LOG("Received key down event: %d\n", key_val); LOG("Received key down event: %d\n", key_val);
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
App::I.key_down(convert_key(key_val)); App::I->key_down(convert_key(key_val));
}); });
break; break;
case AKEY_EVENT_ACTION_UP: case AKEY_EVENT_ACTION_UP:
LOG("Received key up event: %d\n", key_val); LOG("Received key up event: %d\n", key_val);
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
App::I.key_up(convert_key(key_val)); App::I->key_up(convert_key(key_val));
if (uniValue > 32 && uniValue < 127) //printable ascii range if (uniValue > 32 && uniValue < 127) //printable ascii range
App::I.key_char(uniValue); App::I->key_char(uniValue);
}); });
break; break;
} }
@@ -922,7 +923,7 @@ static void engine_handle_cmd(struct android_app* app, int32_t cmd) {
switch (cmd) { switch (cmd) {
case APP_CMD_RESUME: case APP_CMD_RESUME:
LOG("APP_CMD_RESUME"); LOG("APP_CMD_RESUME");
App::I.redraw = true; App::I->redraw = true;
ALooper_wake(engine->app->looper); ALooper_wake(engine->app->looper);
break; break;
case APP_CMD_SAVE_STATE: case APP_CMD_SAVE_STATE:
@@ -941,7 +942,7 @@ static void engine_handle_cmd(struct android_app* app, int32_t cmd) {
break; break;
case APP_CMD_TERM_WINDOW: case APP_CMD_TERM_WINDOW:
// The window is being hidden or closed, clean it up. // The window is being hidden or closed, clean it up.
//App::I.terminate(); //App::I->terminate();
engine_term_display(engine); engine_term_display(engine);
//exit(0); //exit(0);
break; break;
@@ -974,20 +975,20 @@ static void engine_handle_cmd(struct android_app* app, int32_t cmd) {
break; break;
case APP_CMD_WINDOW_REDRAW_NEEDED: case APP_CMD_WINDOW_REDRAW_NEEDED:
LOG("APP_CMD_WINDOW_REDRAW_NEEDED"); LOG("APP_CMD_WINDOW_REDRAW_NEEDED");
App::I.redraw = true; App::I->redraw = true;
ALooper_wake(engine->app->looper); ALooper_wake(engine->app->looper);
break; break;
case APP_CMD_WINDOW_RESIZED: case APP_CMD_WINDOW_RESIZED:
LOG("APP_CMD_WINDOW_RESIZED"); LOG("APP_CMD_WINDOW_RESIZED");
App::I.redraw = true; App::I->redraw = true;
ALooper_wake(engine->app->looper); ALooper_wake(engine->app->looper);
break; break;
case APP_CMD_CONTENT_RECT_CHANGED: case APP_CMD_CONTENT_RECT_CHANGED:
LOG("APP_CMD_CONTENT_RECT_CHANGED"); LOG("APP_CMD_CONTENT_RECT_CHANGED");
//App::I.width = engine->app->contentRect.right - engine->app->contentRect.left; //App::I->width = engine->app->contentRect.right - engine->app->contentRect.left;
//App::I.height = engine->app->contentRect.bottom - engine->app->contentRect.top; //App::I->height = engine->app->contentRect.bottom - engine->app->contentRect.top;
//LOG("content rect %f %f", App::I.width, App::I.height); //LOG("content rect %f %f", App::I->width, App::I->height);
App::I.redraw = true; App::I->redraw = true;
ALooper_wake(engine->app->looper); ALooper_wake(engine->app->looper);
break; break;
} }
@@ -1003,6 +1004,8 @@ void android_main(struct android_app* state) {
// DON'T REMOVE, even if the compiler say it's deprecated // DON'T REMOVE, even if the compiler say it's deprecated
app_dummy(); app_dummy();
App::I = new App;
memset(&g_engine, 0, sizeof(g_engine)); memset(&g_engine, 0, sizeof(g_engine));
state->userData = &g_engine; state->userData = &g_engine;
state->onAppCmd = engine_handle_cmd; state->onAppCmd = engine_handle_cmd;
@@ -1036,8 +1039,8 @@ void android_main(struct android_app* state) {
g_engine.state = *(struct saved_state*)state->savedState; g_engine.state = *(struct saved_state*)state->savedState;
} }
//App::I.create(); //App::I->create();
App::I.redraw = true; App::I->redraw = true;
// loop waiting for stuff to do. // loop waiting for stuff to do.
@@ -1079,7 +1082,7 @@ void android_main(struct android_app* state) {
continue; continue;
if (ident == ALOOPER_POLL_TIMEOUT){ if (ident == ALOOPER_POLL_TIMEOUT){
App::I.redraw = true; App::I->redraw = true;
engine_draw_frame(&g_engine); engine_draw_frame(&g_engine);
} }

12
src/action.cpp
View File

@@ -11,7 +11,7 @@ void ActionManager::add(Action *action)
I.m_actions.emplace(action); I.m_actions.emplace(action);
I.m_memory += action->memory(); I.m_memory += action->memory();
//LOG("History: %.2f KB", I.m_memory / 1024.f); //LOG("History: %.2f KB", I.m_memory / 1024.f);
App::I.update_memory_usage(I.m_memory); App::I->update_memory_usage(I.m_memory);
} }
void ActionManager::undo() void ActionManager::undo()
@@ -27,8 +27,8 @@ void ActionManager::undo()
Canvas::I->m_unsaved = !I.m_actions.top()->was_saved; Canvas::I->m_unsaved = !I.m_actions.top()->was_saved;
I.m_actions.pop(); I.m_actions.pop();
//LOG("History: %.2f KB", I.m_memory / 1024.f); //LOG("History: %.2f KB", I.m_memory / 1024.f);
App::I.update_memory_usage(I.m_memory); App::I->update_memory_usage(I.m_memory);
App::I.title_update(); App::I->title_update();
} }
void ActionManager::redo() void ActionManager::redo()
@@ -44,8 +44,8 @@ void ActionManager::redo()
Canvas::I->m_unsaved = !I.m_redos.top()->was_saved; Canvas::I->m_unsaved = !I.m_redos.top()->was_saved;
I.m_redos.pop(); I.m_redos.pop();
//LOG("History: %.2f KB", I.m_memory / 1024.f); //LOG("History: %.2f KB", I.m_memory / 1024.f);
App::I.update_memory_usage(I.m_memory); App::I->update_memory_usage(I.m_memory);
App::I.title_update(); App::I->title_update();
} }
void ActionManager::clear() void ActionManager::clear()
@@ -56,5 +56,5 @@ void ActionManager::clear()
I.m_redos.pop(); I.m_redos.pop();
I.m_memory = 0; I.m_memory = 0;
//LOG("History: %.2f KB", I.m_memory / 1024.f); //LOG("History: %.2f KB", I.m_memory / 1024.f);
App::I.update_memory_usage(I.m_memory); App::I->update_memory_usage(I.m_memory);
} }

2
src/app.cpp
View File

@@ -22,7 +22,7 @@ void async_unlock();
void destroy_window(); void destroy_window();
#endif #endif
App App::I; // singleton App* App::I = nullptr; // singleton
void App::create() void App::create()
{ {

2
src/app.h
View File

@@ -63,7 +63,7 @@ struct VRController
class App class App
{ {
public: public:
static App I; static App* I;
std::string data_path{ "." }; std::string data_path{ "." };
std::string work_path{ "." }; std::string work_path{ "." };
std::string rec_path{ "." }; std::string rec_path{ "." };

20
src/app_dialogs.cpp
View File

@@ -87,7 +87,7 @@ void App::dialog_newdoc()
layout[main_id]->add_child(dialog); layout[main_id]->add_child(dialog);
layout[main_id]->update(); layout[main_id]->update();
App::I.showKeyboard(); App::I->showKeyboard();
dialog->btn_ok->on_click = [this, dialog](Node*) dialog->btn_ok->on_click = [this, dialog](Node*)
{ {
@@ -121,7 +121,7 @@ void App::dialog_newdoc()
title_update(); title_update();
dialog->destroy(); dialog->destroy();
App::I.hideKeyboard(); App::I->hideKeyboard();
}; };
if (Asset::exist(path)) if (Asset::exist(path))
@@ -147,7 +147,7 @@ void App::dialog_newdoc()
dialog->btn_cancel->on_click = [this, dialog](Node*) dialog->btn_cancel->on_click = [this, dialog](Node*)
{ {
dialog->destroy(); dialog->destroy();
App::I.hideKeyboard(); App::I->hideKeyboard();
}; };
}; };
@@ -355,7 +355,7 @@ void App::dialog_save()
dialog->loaded(); dialog->loaded();
dialog->input->set_text(doc_name); dialog->input->set_text(doc_name);
App::I.showKeyboard(); App::I->showKeyboard();
dialog->btn_ok->on_click = [this, dialog](Node*) dialog->btn_ok->on_click = [this, dialog](Node*)
{ {
@@ -375,7 +375,7 @@ void App::dialog_save()
doc_dir = work_path; doc_dir = work_path;
title_update(); title_update();
dialog->destroy(); dialog->destroy();
App::I.hideKeyboard(); App::I->hideKeyboard();
}; };
if (Asset::exist(path)) if (Asset::exist(path))
@@ -400,7 +400,7 @@ void App::dialog_save()
dialog->btn_cancel->on_click = [this, dialog](Node*) dialog->btn_cancel->on_click = [this, dialog](Node*)
{ {
dialog->destroy(); dialog->destroy();
App::I.hideKeyboard(); App::I->hideKeyboard();
}; };
layout[main_id]->add_child(dialog); layout[main_id]->add_child(dialog);
@@ -496,7 +496,7 @@ void App::dialog_resize()
int res = dialog->get_resolution(); int res = dialog->get_resolution();
if (canvas) if (canvas)
canvas->m_canvas->resize(res, res); canvas->m_canvas->resize(res, res);
App::I.title_update(); App::I->title_update();
ActionManager::clear(); ActionManager::clear();
dialog->destroy(); dialog->destroy();
}; };
@@ -519,7 +519,7 @@ void App::dialog_layer_rename()
dialog->loaded(); dialog->loaded();
dialog->input->set_text(layers->m_current_layer->m_label_text); dialog->input->set_text(layers->m_current_layer->m_label_text);
App::I.showKeyboard(); App::I->showKeyboard();
layout[main_id]->add_child(dialog); layout[main_id]->add_child(dialog);
layout[main_id]->update(); layout[main_id]->update();
@@ -553,11 +553,11 @@ void App::dialog_layer_rename()
layer_node->set_name(dialog->get_name().c_str()); layer_node->set_name(dialog->get_name().c_str());
layer->m_name = dialog->get_name(); layer->m_name = dialog->get_name();
dialog->destroy(); dialog->destroy();
App::I.hideKeyboard(); App::I->hideKeyboard();
}; };
dialog->btn_cancel->on_click = [this, dialog](Node*) dialog->btn_cancel->on_click = [this, dialog](Node*)
{ {
dialog->destroy(); dialog->destroy();
App::I.hideKeyboard(); App::I->hideKeyboard();
}; };
} }

2
src/app_vr.cpp
View File

@@ -323,7 +323,7 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
} }
} }
App::I.grid->draw_heightmap(proj, camera, false); App::I->grid->draw_heightmap(proj, camera, false);
float tan_fov = glm::tan(glm::radians(canvas->m_canvas->m_cam_fov / 2.f)); float tan_fov = glm::tan(glm::radians(canvas->m_canvas->m_cam_fov / 2.f));
glm::vec3 aspect = { (float)uirtt.getWidth() / (float)uirtt.getHeight(), 1.f, 1.f }; glm::vec3 aspect = { (float)uirtt.getWidth() / (float)uirtt.getHeight(), 1.f, 1.f };

28
src/brush.cpp
View File

@@ -167,7 +167,7 @@ void Stroke::add_point(glm::vec3 pos, float pressure)
float aspect_width = glm::min(1.f, glm::clamp(m_brush->m_tip_aspect, .1f, .9f) * 2.f); float aspect_width = glm::min(1.f, glm::clamp(m_brush->m_tip_aspect, .1f, .9f) * 2.f);
float raw_size = glm::clamp(m_brush->m_tip_size / glm::tan(glm::radians(m_camera.fov * 0.5f)), 1.f, m_max_size); float raw_size = glm::clamp(m_brush->m_tip_size / glm::tan(glm::radians(m_camera.fov * 0.5f)), 1.f, m_max_size);
float size = aspect_width * glm::min(m_brush->m_tip_scale.x, m_brush->m_tip_scale.y) * raw_size; float size = aspect_width * glm::min(m_brush->m_tip_scale.x, m_brush->m_tip_scale.y) * raw_size;
m_step = glm::max(0.5f, m_brush->m_tip_spacing * size * App::I.zoom * pressure); m_step = glm::max(0.5f, m_brush->m_tip_spacing * size * App::I->zoom * pressure);
} }
float dist = m_keypoints.empty() ? m_step : float dist = m_keypoints.empty() ? m_step :
@@ -200,7 +200,7 @@ void Stroke::start(const std::shared_ptr<Brush>& brush)
float aspect_width = glm::min(1.f, glm::clamp(m_brush->m_tip_aspect, .1f, .9f) * 2.f); float aspect_width = glm::min(1.f, glm::clamp(m_brush->m_tip_aspect, .1f, .9f) * 2.f);
float raw_size = glm::clamp(m_brush->m_tip_size / glm::tan(glm::radians(m_camera.fov * 0.5f)), 1.f, m_max_size); float raw_size = glm::clamp(m_brush->m_tip_size / glm::tan(glm::radians(m_camera.fov * 0.5f)), 1.f, m_max_size);
float size = aspect_width * glm::min(m_brush->m_tip_scale.x, m_brush->m_tip_scale.y) * raw_size; float size = aspect_width * glm::min(m_brush->m_tip_scale.x, m_brush->m_tip_scale.y) * raw_size;
m_step = glm::max(0.5f, m_brush->m_tip_spacing * size * App::I.zoom); m_step = glm::max(0.5f, m_brush->m_tip_spacing * size * App::I->zoom);
auto hsv = convert_rgb2hsv(m_brush->m_tip_color); auto hsv = convert_rgb2hsv(m_brush->m_tip_color);
if (!m_brush->m_jitter_hsv_eachsample) if (!m_brush->m_jitter_hsv_eachsample)
@@ -371,17 +371,17 @@ bool Brush::read(BinaryStreamReader& r)
r >> d; r >> d;
d.value<Serializer::CString>("m_name", m_name); d.value<Serializer::CString>("m_name", m_name);
d.value<Serializer::CString>("m_brush_path", m_brush_path); d.value<Serializer::CString>("m_brush_path", m_brush_path);
m_brush_path = str_replace(m_brush_path, "{data_path}", App::I.data_path); m_brush_path = str_replace(m_brush_path, "{data_path}", App::I->data_path);
d.value<Serializer::CString>("m_brush_thumb_path", m_brush_thumb_path); d.value<Serializer::CString>("m_brush_thumb_path", m_brush_thumb_path);
m_brush_thumb_path = str_replace(m_brush_thumb_path, "{data_path}", App::I.data_path); m_brush_thumb_path = str_replace(m_brush_thumb_path, "{data_path}", App::I->data_path);
d.value<Serializer::CString>("m_dual_path", m_dual_path); d.value<Serializer::CString>("m_dual_path", m_dual_path);
m_dual_path = str_replace(m_dual_path, "{data_path}", App::I.data_path); m_dual_path = str_replace(m_dual_path, "{data_path}", App::I->data_path);
d.value<Serializer::CString>("m_dual_thumb_path", m_dual_thumb_path); d.value<Serializer::CString>("m_dual_thumb_path", m_dual_thumb_path);
m_dual_thumb_path = str_replace(m_dual_thumb_path, "{data_path}", App::I.data_path); m_dual_thumb_path = str_replace(m_dual_thumb_path, "{data_path}", App::I->data_path);
d.value<Serializer::CString>("m_pattern_path", m_pattern_path); d.value<Serializer::CString>("m_pattern_path", m_pattern_path);
m_pattern_path = str_replace(m_pattern_path, "{data_path}", App::I.data_path); m_pattern_path = str_replace(m_pattern_path, "{data_path}", App::I->data_path);
d.value<Serializer::CString>("m_pattern_thumb_path", m_pattern_thumb_path); d.value<Serializer::CString>("m_pattern_thumb_path", m_pattern_thumb_path);
m_pattern_thumb_path = str_replace(m_pattern_thumb_path, "{data_path}", App::I.data_path); m_pattern_thumb_path = str_replace(m_pattern_thumb_path, "{data_path}", App::I->data_path);
d.value<Serializer::Vec4>("m_tip_color", m_tip_color); d.value<Serializer::Vec4>("m_tip_color", m_tip_color);
d.value<Serializer::Vec2>("m_tip_scale", m_tip_scale); d.value<Serializer::Vec2>("m_tip_scale", m_tip_scale);
@@ -463,17 +463,17 @@ void Brush::write(BinaryStreamWriter& w) const
d.name = L"Brush class"; d.name = L"Brush class";
d.props["m_name"] = std::make_shared<Serializer::CString>(m_name); d.props["m_name"] = std::make_shared<Serializer::CString>(m_name);
d.props["m_brush_path"] = std::make_shared<Serializer::CString>( d.props["m_brush_path"] = std::make_shared<Serializer::CString>(
str_replace(m_brush_path, App::I.data_path, "{data_path}")); str_replace(m_brush_path, App::I->data_path, "{data_path}"));
d.props["m_brush_thumb_path"] = std::make_shared<Serializer::CString>( d.props["m_brush_thumb_path"] = std::make_shared<Serializer::CString>(
str_replace(m_brush_thumb_path, App::I.data_path, "{data_path}")); str_replace(m_brush_thumb_path, App::I->data_path, "{data_path}"));
d.props["m_dual_path"] = std::make_shared<Serializer::CString>( d.props["m_dual_path"] = std::make_shared<Serializer::CString>(
str_replace(m_dual_path, App::I.data_path, "{data_path}")); str_replace(m_dual_path, App::I->data_path, "{data_path}"));
d.props["m_dual_thumb_path"] = std::make_shared<Serializer::CString>( d.props["m_dual_thumb_path"] = std::make_shared<Serializer::CString>(
str_replace(m_dual_thumb_path, App::I.data_path, "{data_path}")); str_replace(m_dual_thumb_path, App::I->data_path, "{data_path}"));
d.props["m_pattern_path"] = std::make_shared<Serializer::CString>( d.props["m_pattern_path"] = std::make_shared<Serializer::CString>(
str_replace(m_pattern_path, App::I.data_path, "{data_path}")); str_replace(m_pattern_path, App::I->data_path, "{data_path}"));
d.props["m_pattern_thumb_path"] = std::make_shared<Serializer::CString>( d.props["m_pattern_thumb_path"] = std::make_shared<Serializer::CString>(
str_replace(m_pattern_thumb_path, App::I.data_path, "{data_path}")); str_replace(m_pattern_thumb_path, App::I->data_path, "{data_path}"));
d.props["m_tip_color"] = std::make_shared<Serializer::Vec4>(m_tip_color); d.props["m_tip_color"] = std::make_shared<Serializer::Vec4>(m_tip_color);
d.props["m_tip_scale"] = std::make_shared<Serializer::Vec2>(m_tip_scale); d.props["m_tip_scale"] = std::make_shared<Serializer::Vec2>(m_tip_scale);

130
src/canvas.cpp
View File

@@ -291,7 +291,7 @@ std::array<std::vector<vertex_t>, 6> Canvas::stroke_draw_project(std::array<vert
{ {
glm::vec4 plane_local = plane_camera * glm::vec4(hit, 1); glm::vec4 plane_local = plane_camera * glm::vec4(hit, 1);
//P[j].uvs2 = xy(P[j].pos) / glm::vec2(App::I.width, App::I.height); //P[j].uvs2 = xy(P[j].pos) / glm::vec2(App::I->width, App::I->height);
vertex_t v; vertex_t v;
v.pos.x = -(plane_local.x * 0.5f - 0.5f) * m_width; v.pos.x = -(plane_local.x * 0.5f - 0.5f) * m_width;
v.pos.y = (plane_local.y * 0.5f + 0.5f) * m_height; v.pos.y = (plane_local.y * 0.5f + 0.5f) * m_height;
@@ -411,18 +411,18 @@ std::vector<Canvas::StrokeFrame> Canvas::stroke_draw_compute(Stroke& stroke) con
+dx - dy, // D - bottom-right +dx - dy, // D - bottom-right
}; };
glm::vec2 mixer_sz(App::I.width, App::I.height); glm::vec2 mixer_sz(App::I->width, App::I->height);
glm::vec2 mixer_bb_min(mixer_sz); glm::vec2 mixer_bb_min(mixer_sz);
glm::vec2 mixer_bb_max(0, 0); glm::vec2 mixer_bb_max(0, 0);
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
{ {
auto p = (xy(prev.pos) + App::I.zoom * s.scale * off_mix[j] * glm::orientate2(-s.angle)); auto p = (xy(prev.pos) + App::I->zoom * s.scale * off_mix[j] * glm::orientate2(-s.angle));
mixer_bb_min = glm::max({ 0, 0 }, glm::min(mixer_bb_min, p)); mixer_bb_min = glm::max({ 0, 0 }, glm::min(mixer_bb_min, p));
mixer_bb_max = glm::min(mixer_sz, glm::max(mixer_bb_max, p)); mixer_bb_max = glm::min(mixer_sz, glm::max(mixer_bb_max, p));
if (s.pos.z == 0.f) if (s.pos.z == 0.f)
{ {
B[j].pos = glm::vec4(xy(s.pos) + App::I.zoom * s.scale * off[j] * glm::orientate2(-s.angle) - glm::vec2(0, 1), 1, 1); B[j].pos = glm::vec4(xy(s.pos) + App::I->zoom * s.scale * off[j] * glm::orientate2(-s.angle) - glm::vec2(0, 1), 1, 1);
} }
else else
{ {
@@ -433,7 +433,7 @@ std::vector<Canvas::StrokeFrame> Canvas::stroke_draw_compute(Stroke& stroke) con
B[j].uvs2 = p / mixer_sz; B[j].uvs2 = p / mixer_sz;
} }
f.m_mixer_rect = glm::vec4(glm::floor(mixer_bb_min), glm::ceil(mixer_bb_max - mixer_bb_min)) / App::I.zoom; f.m_mixer_rect = glm::vec4(glm::floor(mixer_bb_min), glm::ceil(mixer_bb_max - mixer_bb_min)) / App::I->zoom;
f.col = glm::vec4(s.col, 1); f.col = glm::vec4(s.col, 1);
f.flow = s.flow; f.flow = s.flow;
f.opacity = s.opacity; f.opacity = s.opacity;
@@ -695,7 +695,7 @@ void Canvas::stroke_commit()
m_dirty = false; m_dirty = false;
m_dirty_stroke = true; // new stroke ready for timelapse capture m_dirty_stroke = true; // new stroke ready for timelapse capture
App::I.redraw = true; App::I->redraw = true;
// save viewport and clear color states // save viewport and clear color states
GLint vp[4]; GLint vp[4];
@@ -709,7 +709,7 @@ void Canvas::stroke_commit()
action->was_saved = !m_unsaved; action->was_saved = !m_unsaved;
m_unsaved = true; m_unsaved = true;
App::I.title_update(); App::I->title_update();
// prepare common states // prepare common states
glViewport(0, 0, m_width, m_height); glViewport(0, 0, m_width, m_height);
@@ -1217,7 +1217,7 @@ void Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
{ {
m_dirty = false; m_dirty = false;
App::I.render_task([&] App::I->render_task([&]
{ {
// prepare common states // prepare common states
glViewport(0, 0, m_width, m_height); glViewport(0, 0, m_width, m_height);
@@ -1438,7 +1438,7 @@ void Canvas::FloodData::apply()
if (!dirty[plane]) if (!dirty[plane])
continue; continue;
auto& rtt = layer->m_rtt[plane]; auto& rtt = layer->m_rtt[plane];
App::I.render_task([&] App::I->render_task([&]
{ {
rtt.bindTexture(); rtt.bindTexture();
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rtt.getWidth(), rtt.getHeight(), glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rtt.getWidth(), rtt.getHeight(),
@@ -1575,7 +1575,7 @@ void Canvas::clear_context()
void Canvas::import_equirectangular(std::string file_path, std::shared_ptr<Layer> layer /*= nullptr*/) void Canvas::import_equirectangular(std::string file_path, std::shared_ptr<Layer> layer /*= nullptr*/)
{ {
if (App::I.check_license()) if (App::I->check_license())
{ {
std::thread t([=] { std::thread t([=] {
BT_SetTerminate(); BT_SetTerminate();
@@ -1657,7 +1657,7 @@ void Canvas::import_equirectangular_thread(std::string file_path, std::shared_pt
void Canvas::export_equirectangular(std::string file_path, std::function<void()> on_complete) void Canvas::export_equirectangular(std::string file_path, std::function<void()> on_complete)
{ {
if (App::I.check_license()) if (App::I->check_license())
{ {
std::thread t([=] { std::thread t([=] {
BT_SetTerminate(); BT_SetTerminate();
@@ -1672,16 +1672,16 @@ void Canvas::export_equirectangular(std::string file_path, std::function<void()>
void Canvas::export_equirectangular_thread(std::string file_path) void Canvas::export_equirectangular_thread(std::string file_path)
{ {
std::shared_ptr<NodeProgressBar> pb; std::shared_ptr<NodeProgressBar> pb;
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb = std::make_shared<NodeProgressBar>(); pb = std::make_shared<NodeProgressBar>();
pb->m_manager = &App::I.layout; pb->m_manager = &App::I->layout;
pb->init(); pb->init();
pb->create(); pb->create();
pb->loaded(); pb->loaded();
pb->m_progress->SetWidthP(0); pb->m_progress->SetWidthP(0);
pb->m_title->set_text("Export Pano Image"); pb->m_title->set_text("Export Pano Image");
App::I.layout[App::I.main_id]->add_child(pb); App::I->layout[App::I->main_id]->add_child(pb);
} }
RTT m_latlong; RTT m_latlong;
@@ -1697,7 +1697,7 @@ void Canvas::export_equirectangular_thread(std::string file_path)
GL_TEXTURE_CUBE_MAP_POSITIVE_Y, // bottom GL_TEXTURE_CUBE_MAP_POSITIVE_Y, // bottom
}; };
App::I.render_task([&] App::I->render_task([&]
{ {
glGenTextures(1, &cube_id); glGenTextures(1, &cube_id);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id); glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id);
@@ -1716,7 +1716,7 @@ void Canvas::export_equirectangular_thread(std::string file_path)
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
// prepare common states // prepare common states
glViewport(0, 0, m_width, m_height); glViewport(0, 0, m_width, m_height);
@@ -1795,7 +1795,7 @@ void Canvas::export_equirectangular_thread(std::string file_path)
float p = (float)progress / total * 100.f; float p = (float)progress / total * 100.f;
LOG("progress: %f", p); LOG("progress: %f", p);
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->m_progress->SetWidthP(p); pb->m_progress->SetWidthP(p);
} }
@@ -1813,7 +1813,7 @@ void Canvas::export_equirectangular_thread(std::string file_path)
// int ret = stbi_write_png(name, m_tmp[i].getWidth(), m_tmp[i].getHeight(), 4, data.get(), m_tmp[i].stride()); // int ret = stbi_write_png(name, m_tmp[i].getWidth(), m_tmp[i].getHeight(), 4, data.get(), m_tmp[i].stride());
//} //}
App::I.render_task([&] App::I->render_task([&]
{ {
glDisable(GL_BLEND); glDisable(GL_BLEND);
glViewport(0, 0, m_latlong.getWidth(), m_latlong.getHeight()); glViewport(0, 0, m_latlong.getWidth(), m_latlong.getHeight());
@@ -1836,7 +1836,7 @@ void Canvas::export_equirectangular_thread(std::string file_path)
progress++; progress++;
LOG("progress: %f", (float)progress / total * 100.f); LOG("progress: %f", (float)progress / total * 100.f);
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->m_progress->SetWidthP((float)progress / total * 100.f); pb->m_progress->SetWidthP((float)progress / total * 100.f);
} }
@@ -1855,7 +1855,7 @@ void Canvas::export_equirectangular_thread(std::string file_path)
progress++; progress++;
LOG("progress: %f", (float)progress / total * 100.f); LOG("progress: %f", (float)progress / total * 100.f);
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->m_progress->SetWidthP((float)progress / total * 100.f); pb->m_progress->SetWidthP((float)progress / total * 100.f);
} }
@@ -1876,13 +1876,13 @@ void Canvas::export_equirectangular_thread(std::string file_path)
}]; }];
#endif #endif
App::I.render_task_async([id=cube_id] App::I->render_task_async([id=cube_id]
{ {
glDeleteTextures(1, &id); glDeleteTextures(1, &id);
}); });
m_latlong.destroy(); m_latlong.destroy();
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->destroy(); pb->destroy();
} }
@@ -1938,7 +1938,7 @@ void Canvas::inject_xmp(std::string jpg_path)
void Canvas::export_depth(std::string file_name, std::function<void()> on_complete) void Canvas::export_depth(std::string file_name, std::function<void()> on_complete)
{ {
if (App::I.check_license()) if (App::I->check_license())
{ {
std::thread t([=] { std::thread t([=] {
export_depth_thread(file_name); export_depth_thread(file_name);
@@ -1957,7 +1957,7 @@ void Canvas::export_depth_thread(std::string file_name)
glm::mat4 proj = glm::perspective(glm::radians(m_cam_fov), (float)rtt.getWidth() / (float)rtt.getHeight(), 0.1f, 100.f); glm::mat4 proj = glm::perspective(glm::radians(m_cam_fov), (float)rtt.getWidth() / (float)rtt.getHeight(), 0.1f, 100.f);
glm::mat4 camera = m_cam_rot; glm::mat4 camera = m_cam_rot;
App::I.render_task([&] App::I->render_task([&]
{ {
draw_merge(); draw_merge();
@@ -1999,11 +1999,11 @@ void Canvas::export_depth_thread(std::string file_name)
uint8_t* rgba_data = rtt.readTextureData(); uint8_t* rgba_data = rtt.readTextureData();
stbi_flip_vertically_on_write(true); stbi_flip_vertically_on_write(true);
std::string path_rgba = App::I.work_path + "/" + file_name + ".png"; std::string path_rgba = App::I->work_path + "/" + file_name + ".png";
stbi_write_jpg(path_rgba.c_str(), rtt.getWidth(), rtt.getHeight(), 4, rgba_data, 100); stbi_write_jpg(path_rgba.c_str(), rtt.getWidth(), rtt.getHeight(), 4, rgba_data, 100);
delete rgba_data; delete rgba_data;
App::I.render_task([&] App::I->render_task([&]
{ {
rtt.bindFramebuffer(); rtt.bindFramebuffer();
rtt.clear({ 0, 0, 0, 1 }); rtt.clear({ 0, 0, 0, 1 });
@@ -2041,7 +2041,7 @@ void Canvas::export_depth_thread(std::string file_name)
}); });
uint8_t* depth_data = rtt.readTextureData(); uint8_t* depth_data = rtt.readTextureData();
std::string path_depth = App::I.work_path + "/" + file_name + "_depth.png"; std::string path_depth = App::I->work_path + "/" + file_name + "_depth.png";
stbi_write_jpg(path_depth.c_str(), rtt.getWidth(), rtt.getHeight(), 4, depth_data, 100); stbi_write_jpg(path_depth.c_str(), rtt.getWidth(), rtt.getHeight(), 4, depth_data, 100);
delete depth_data; delete depth_data;
stbi_flip_vertically_on_write(false); stbi_flip_vertically_on_write(false);
@@ -2051,7 +2051,7 @@ void Canvas::export_depth_thread(std::string file_name)
void Canvas::export_layers(std::string file_name, std::function<void()> on_complete) void Canvas::export_layers(std::string file_name, std::function<void()> on_complete)
{ {
if (App::I.check_license()) if (App::I->check_license())
{ {
std::thread t([=] { std::thread t([=] {
BT_SetTerminate(); BT_SetTerminate();
@@ -2066,16 +2066,16 @@ void Canvas::export_layers(std::string file_name, std::function<void()> on_compl
void Canvas::export_layers_thread(std::string file_name) void Canvas::export_layers_thread(std::string file_name)
{ {
std::shared_ptr<NodeProgressBar> pb; std::shared_ptr<NodeProgressBar> pb;
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb = std::make_shared<NodeProgressBar>(); pb = std::make_shared<NodeProgressBar>();
pb->m_manager = &App::I.layout; pb->m_manager = &App::I->layout;
pb->init(); pb->init();
pb->create(); pb->create();
pb->loaded(); pb->loaded();
pb->m_progress->SetWidthP(0); pb->m_progress->SetWidthP(0);
pb->m_title->set_text("Export Pano Layers"); pb->m_title->set_text("Export Pano Layers");
App::I.layout[App::I.main_id]->add_child(pb); App::I->layout[App::I->main_id]->add_child(pb);
} }
int progress = 0; int progress = 0;
int total = (int)(m_layers.size() + 1) * 6; int total = (int)(m_layers.size() + 1) * 6;
@@ -2092,7 +2092,7 @@ void Canvas::export_layers_thread(std::string file_name)
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, // top GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, // top
GL_TEXTURE_CUBE_MAP_POSITIVE_Y, // bottom GL_TEXTURE_CUBE_MAP_POSITIVE_Y, // bottom
}; };
App::I.render_task([&] App::I->render_task([&]
{ {
glGenTextures(1, &cube_id); glGenTextures(1, &cube_id);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id); glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id);
@@ -2105,7 +2105,7 @@ void Canvas::export_layers_thread(std::string file_name)
{ {
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
glEnable(GL_BLEND); glEnable(GL_BLEND);
glViewport(0, 0, m_width, m_height); glViewport(0, 0, m_width, m_height);
@@ -2150,13 +2150,13 @@ void Canvas::export_layers_thread(std::string file_name)
float p = (float)progress / total * 100.f; float p = (float)progress / total * 100.f;
LOG("progress: %f", p); LOG("progress: %f", p);
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->m_progress->SetWidthP(p); pb->m_progress->SetWidthP(p);
} }
} }
App::I.render_task([&] App::I->render_task([&]
{ {
glViewport(0, 0, m_latlong.getWidth(), m_latlong.getHeight()); glViewport(0, 0, m_latlong.getWidth(), m_latlong.getHeight());
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
@@ -2178,7 +2178,7 @@ void Canvas::export_layers_thread(std::string file_name)
auto latlong_data = std::make_unique<uint8_t[]>(m_latlong.bytes()); auto latlong_data = std::make_unique<uint8_t[]>(m_latlong.bytes());
m_latlong.readTextureData(latlong_data.get()); m_latlong.readTextureData(latlong_data.get());
static char name[128]; static char name[128];
sprintf(name, "%s/%s-layer-%02d.png", App::I.work_path.c_str(), file_name.c_str(), seq); sprintf(name, "%s/%s-layer-%02d.png", App::I->work_path.c_str(), file_name.c_str(), seq);
seq++; seq++;
LOG("writing %s", name); LOG("writing %s", name);
int ret = stbi_write_png(name, m_latlong.getWidth(), m_latlong.getHeight(), 4, latlong_data.get(), m_latlong.stride()); int ret = stbi_write_png(name, m_latlong.getWidth(), m_latlong.getHeight(), 4, latlong_data.get(), m_latlong.stride());
@@ -2188,19 +2188,19 @@ void Canvas::export_layers_thread(std::string file_name)
float p = (float)progress / total * 100.f; float p = (float)progress / total * 100.f;
LOG("progress: %f", p); LOG("progress: %f", p);
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->m_progress->SetWidthP(p); pb->m_progress->SetWidthP(p);
} }
} }
App::I.render_task([&] App::I->render_task([&]
{ {
glDeleteTextures(1, &cube_id); glDeleteTextures(1, &cube_id);
m_latlong.destroy(); m_latlong.destroy();
}); });
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->destroy(); pb->destroy();
} }
@@ -2208,7 +2208,7 @@ void Canvas::export_layers_thread(std::string file_name)
void Canvas::export_cubes() void Canvas::export_cubes()
{ {
if (!App::I.check_license()) if (!App::I->check_license())
return; return;
#ifdef __OBJC__ #ifdef __OBJC__
NSMutableArray* files = [NSMutableArray array]; NSMutableArray* files = [NSMutableArray array];
@@ -2255,7 +2255,7 @@ void Canvas::export_cubes()
} }
static char name[128]; static char name[128];
sprintf(name, "%s-%02d-%d.png", App::I.work_path.c_str(), layer, plane); sprintf(name, "%s-%02d-%d.png", App::I->work_path.c_str(), layer, plane);
int ret = stbi_write_png(name, m_width, m_height, 4, buffer.get(), 0); int ret = stbi_write_png(name, m_width, m_height, 4, buffer.get(), 0);
@@ -2280,7 +2280,7 @@ void Canvas::export_cubes()
} }
#ifdef __OBJC__ #ifdef __OBJC__
static char name[128]; static char name[128];
sprintf(name, "%s.zip", App::I.work_path.c_str()); sprintf(name, "%s.zip", App::I->work_path.c_str());
auto zip_path = [NSString stringWithUTF8String : name]; auto zip_path = [NSString stringWithUTF8String : name];
//[SSZipArchive createZipFileAtPath:zip_path withFilesAtPaths:files]; //[SSZipArchive createZipFileAtPath:zip_path withFilesAtPaths:files];
for (NSString* f : files) for (NSString* f : files)
@@ -2290,11 +2290,11 @@ void Canvas::export_cubes()
void Canvas::project_save(std::function<void(bool)> on_complete) void Canvas::project_save(std::function<void(bool)> on_complete)
{ {
if (App::I.check_license()) if (App::I->check_license())
{ {
std::thread t([=] { std::thread t([=] {
BT_SetTerminate(); BT_SetTerminate();
bool ret = project_save_thread(App::I.doc_path); bool ret = project_save_thread(App::I->doc_path);
if (on_complete) if (on_complete)
on_complete(ret); on_complete(ret);
}); });
@@ -2305,7 +2305,7 @@ void Canvas::project_save(std::function<void(bool)> on_complete)
void Canvas::project_save(std::string file_path, std::function<void(bool)> on_complete) void Canvas::project_save(std::string file_path, std::function<void(bool)> on_complete)
{ {
LOG("saving %s", file_path.c_str()); LOG("saving %s", file_path.c_str());
if (App::I.check_license()) if (App::I->check_license())
{ {
std::thread t([=] { std::thread t([=] {
BT_SetTerminate(); BT_SetTerminate();
@@ -2324,7 +2324,7 @@ void Canvas::project_save(std::string file_path, std::function<void(bool)> on_co
bool Canvas::project_save_thread(std::string file_path) bool Canvas::project_save_thread(std::string file_path)
{ {
// already saved, nothing to do // already saved, nothing to do
if (!m_unsaved && file_path == App::I.doc_path) if (!m_unsaved && file_path == App::I->doc_path)
{ {
LOG("already saved"); LOG("already saved");
return true; return true;
@@ -2336,7 +2336,7 @@ bool Canvas::project_save_thread(std::string file_path)
auto start = file_path.rfind('/') + 1; auto start = file_path.rfind('/') + 1;
std::string file_name = file_path.substr(start, file_path.length() - start - strlen(".ppi")); std::string file_name = file_path.substr(start, file_path.length() - start - strlen(".ppi"));
std::string tmp_path = App::I.data_path + '/' + file_name + ".tmp.ppi"; std::string tmp_path = App::I->data_path + '/' + file_name + ".tmp.ppi";
LOG("file name %s", file_name.c_str()); LOG("file name %s", file_name.c_str());
LOG("tmp path %s", tmp_path.c_str()); LOG("tmp path %s", tmp_path.c_str());
@@ -2375,13 +2375,13 @@ bool Canvas::project_save_thread(std::string file_path)
// load thumbnail // load thumbnail
Image thumb = thumbnail_generate(ppi_header.thumb_header.width, ppi_header.thumb_header.height); Image thumb = thumbnail_generate(ppi_header.thumb_header.width, ppi_header.thumb_header.height);
auto pb = std::make_shared<NodeProgressBar>(); auto pb = std::make_shared<NodeProgressBar>();
pb->m_manager = &App::I.layout; pb->m_manager = &App::I->layout;
pb->init(); pb->init();
pb->create(); pb->create();
pb->loaded(); pb->loaded();
pb->m_progress->SetWidthP(0); pb->m_progress->SetWidthP(0);
pb->m_title->set_text("Saving Pano Project"); pb->m_title->set_text("Saving Pano Project");
App::I.layout[App::I.main_id]->add_child(pb); App::I->layout[App::I->main_id]->add_child(pb);
thumb.flip(); thumb.flip();
fwrite(thumb.data(), thumb.size(), 1, fp); fwrite(thumb.data(), thumb.size(), 1, fp);
@@ -2484,7 +2484,7 @@ bool Canvas::project_save_thread(std::string file_path)
} }
pb->destroy(); pb->destroy();
App::I.title_update(); App::I->title_update();
return success; return success;
} }
@@ -2519,16 +2519,16 @@ bool Canvas::project_open_thread(std::string file_path)
} }
std::shared_ptr<NodeProgressBar> pb; std::shared_ptr<NodeProgressBar> pb;
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb = std::make_shared<NodeProgressBar>(); pb = std::make_shared<NodeProgressBar>();
pb->m_manager = &App::I.layout; pb->m_manager = &App::I->layout;
pb->init(); pb->init();
pb->create(); pb->create();
pb->loaded(); pb->loaded();
pb->m_progress->SetWidthP(0); pb->m_progress->SetWidthP(0);
pb->m_title->set_text("Opening Pano Project"); pb->m_title->set_text("Opening Pano Project");
App::I.layout[App::I.main_id]->add_child(pb); App::I->layout[App::I->main_id]->add_child(pb);
} }
// skip thumbnail // skip thumbnail
@@ -2615,7 +2615,7 @@ bool Canvas::project_open_thread(std::string file_path)
float p = (float)progress / total * 100.f; float p = (float)progress / total * 100.f;
LOG("progress: %f", p); LOG("progress: %f", p);
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->m_progress->SetWidthP(p); pb->m_progress->SetWidthP(p);
} }
@@ -2643,10 +2643,10 @@ bool Canvas::project_open_thread(std::string file_path)
memset(m_pick_ready, 0, sizeof(bool) * 6); memset(m_pick_ready, 0, sizeof(bool) * 6);
m_unsaved = false; m_unsaved = false;
m_newdoc = false; m_newdoc = false;
if (App::I.layout.m_loaded) if (App::I->layout.m_loaded)
{ {
pb->destroy(); pb->destroy();
App::I.title_update(); App::I->title_update();
} }
return true; return true;
} }
@@ -2656,7 +2656,7 @@ Image Canvas::thumbnail_generate(int w, int h)
Image image; Image image;
image.create(w, h); image.create(w, h);
App::I.render_task([this, w, h, &image] App::I->render_task([this, w, h, &image]
{ {
// save viewport and clear color states // save viewport and clear color states
GLint vp[4]; GLint vp[4];
@@ -2795,7 +2795,7 @@ Image Canvas::thumbnail_read(std::string file_path)
void Canvas::draw_objects_direct(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer, Layer& layer) void Canvas::draw_objects_direct(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer, Layer& layer)
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
// save viewport and clear color states // save viewport and clear color states
GLint vp[4]; GLint vp[4];
@@ -2842,7 +2842,7 @@ void Canvas::draw_objects_direct(std::function<void(const glm::mat4& camera, con
void Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer, Layer& layer) void Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer, Layer& layer)
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
// save viewport and clear color states // save viewport and clear color states
GLint vp[4]; GLint vp[4];
@@ -3105,7 +3105,7 @@ void Layer::restore(const Snapshot& snap)
// it's just a quick fix DON'T SHIP!! // it's just a quick fix DON'T SHIP!!
//m_rtt[i].recreate(); //m_rtt[i].recreate();
App::I.render_task_async([this,i,&snap] App::I->render_task_async([this,i,&snap]
{ {
m_rtt[i].bindTexture(); m_rtt[i].bindTexture();
glm::vec2 box_sz = zw(m_dirty_box[i]) - xy(m_dirty_box[i]); glm::vec2 box_sz = zw(m_dirty_box[i]) - xy(m_dirty_box[i]);
@@ -3118,7 +3118,7 @@ void Layer::restore(const Snapshot& snap)
(int)box_sz.x * (int)box_sz.y * 4, (int)box_sz.x, (int)box_sz.y); (int)box_sz.x * (int)box_sz.y * 4, (int)box_sz.x, (int)box_sz.y);
}); });
} }
App::I.render_sync(); App::I->render_sync();
} }
Layer::Snapshot Layer::snapshot(std::array<glm::vec4, 6> * dirty_box /*= nullptr*/, std::array<bool, 6> * dirty_face /*= nullptr*/) Layer::Snapshot Layer::snapshot(std::array<glm::vec4, 6> * dirty_box /*= nullptr*/, std::array<bool, 6> * dirty_face /*= nullptr*/)
@@ -3136,7 +3136,7 @@ Layer::Snapshot Layer::snapshot(std::array<glm::vec4, 6> * dirty_box /*= nullptr
snap.image[i] = std::make_unique<uint8_t[]>(m_rtt[i].bytes()); snap.image[i] = std::make_unique<uint8_t[]>(m_rtt[i].bytes());
App::I.render_task_async([this,i,&snap] App::I->render_task_async([this,i,&snap]
{ {
m_rtt[i].bindFramebuffer(); m_rtt[i].bindFramebuffer();
glm::vec2 box_sz = zw(snap.m_dirty_box[i]) - xy(snap.m_dirty_box[i]); glm::vec2 box_sz = zw(snap.m_dirty_box[i]) - xy(snap.m_dirty_box[i]);
@@ -3145,13 +3145,13 @@ Layer::Snapshot Layer::snapshot(std::array<glm::vec4, 6> * dirty_box /*= nullptr
m_rtt[i].unbindFramebuffer(); m_rtt[i].unbindFramebuffer();
}); });
} }
App::I.render_sync(); App::I->render_sync();
return snap; return snap;
} }
void Layer::clear(const glm::vec4& c) void Layer::clear(const glm::vec4& c)
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
// push clear color state // push clear color state
GLfloat cc[4]; GLfloat cc[4];
@@ -3188,7 +3188,7 @@ bool Layer::create(int width, int height, std::string name)
m_name = name; m_name = name;
w = width; w = width;
h = height; h = height;
App::I.render_task([&] App::I->render_task([&]
{ {
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
{ {

4
src/canvas_actions.cpp
View File

@@ -34,7 +34,7 @@ void ActionStroke::undo()
glm::vec2 box_sz = zw(m_box[i]) - xy(m_box[i]); glm::vec2 box_sz = zw(m_box[i]) - xy(m_box[i]);
if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= m_canvas->m_layers[m_layer_idx]->w && box_sz.y <= m_canvas->m_layers[m_layer_idx]->h) if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= m_canvas->m_layers[m_layer_idx]->w && box_sz.y <= m_canvas->m_layers[m_layer_idx]->h)
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
m_canvas->m_layers[m_layer_idx]->m_rtt[i].bindTexture(); m_canvas->m_layers[m_layer_idx]->m_rtt[i].bindTexture();
glTexSubImage2D(GL_TEXTURE_2D, 0, (int)m_box[i].x, (int)m_box[i].y, (int)box_sz.x, (int)box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, m_image[i].get()); glTexSubImage2D(GL_TEXTURE_2D, 0, (int)m_box[i].x, (int)m_box[i].y, (int)box_sz.x, (int)box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, m_image[i].get());
@@ -77,7 +77,7 @@ Action* ActionStroke::get_redo()
if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= layer->w && box_sz.y <= layer->h) if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= layer->w && box_sz.y <= layer->h)
{ {
action->m_image[i] = std::make_unique<uint8_t[]>(box_sz.x * box_sz.y * 4); action->m_image[i] = std::make_unique<uint8_t[]>(box_sz.x * box_sz.y * 4);
App::I.render_task([&] App::I->render_task([&]
{ {
layer->m_rtt[i].bindFramebuffer(); layer->m_rtt[i].bindFramebuffer();
glReadPixels(box_or.x, box_or.y, box_sz.x, box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, action->m_image[i].get()); glReadPixels(box_or.x, box_or.y, box_sz.x, box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, action->m_image[i].get());

66
src/canvas_modes.cpp
View File

@@ -31,9 +31,9 @@ void CanvasModeBasicCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
// } // }
break; break;
case kEventType::MouseDownR: case kEventType::MouseDownR:
if (App::I.keys[(int)kKey::KeyAlt]) if (App::I->keys[(int)kKey::KeyAlt])
break; break;
m_zooming = App::I.keys[(int)kKey::KeyCtrl]; m_zooming = App::I->keys[(int)kKey::KeyCtrl];
m_draggingR = true; m_draggingR = true;
m_dragR_start = me->m_pos; m_dragR_start = me->m_pos;
m_pan_start = Canvas::I->m_pan; m_pan_start = Canvas::I->m_pan;
@@ -53,7 +53,7 @@ void CanvasModeBasicCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
} }
else else
{ {
auto dir = (App::I.has_vr && App::I.vr_active) ? glm::vec2(1, 1) : glm::vec2(-1, -1); auto dir = (App::I->has_vr && App::I->vr_active) ? glm::vec2(1, 1) : glm::vec2(-1, -1);
Canvas::I->m_pan = m_pan_start + (me->m_pos - m_dragR_start) * dir * (Canvas::I->m_cam_fov / 85.f); Canvas::I->m_pan = m_pan_start + (me->m_pos - m_dragR_start) * dir * (Canvas::I->m_cam_fov / 85.f);
auto angle = Canvas::I->m_pan * 0.003f; auto angle = Canvas::I->m_pan * 0.003f;
Canvas::I->m_cam_rot = glm::eulerAngleXY(angle.y, angle.x); Canvas::I->m_cam_rot = glm::eulerAngleXY(angle.y, angle.x);
@@ -63,7 +63,7 @@ void CanvasModeBasicCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
case kEventType::MouseScroll: case kEventType::MouseScroll:
m_zoom_canvas += me->m_scroll_delta * 0.1f; m_zoom_canvas += me->m_scroll_delta * 0.1f;
Canvas::I->m_cam_fov -= me->m_scroll_delta * 2.0f; Canvas::I->m_cam_fov -= me->m_scroll_delta * 2.0f;
App::I.brush_update(); App::I->brush_update();
break; break;
case kEventType::MouseCancel: case kEventType::MouseCancel:
m_draggingR = false; m_draggingR = false;
@@ -89,7 +89,7 @@ void CanvasModeBasicCamera::on_GestureEvent(GestureEvent* ge)
Canvas::I->m_cam_fov = m_camera_fov - ge->m_distance_delta * .05f; Canvas::I->m_cam_fov = m_camera_fov - ge->m_distance_delta * .05f;
auto angle = Canvas::I->m_pan * 0.003f; auto angle = Canvas::I->m_pan * 0.003f;
Canvas::I->m_cam_rot = glm::eulerAngleXY(angle.y, angle.x); Canvas::I->m_cam_rot = glm::eulerAngleXY(angle.y, angle.x);
App::I.brush_update(); App::I->brush_update();
break; break;
} }
default: default:
@@ -125,17 +125,17 @@ void CanvasModePen::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
switch (me->m_type) switch (me->m_type)
{ {
case kEventType::MouseDownL: case kEventType::MouseDownL:
if (App::I.keys[(int)kKey::KeyAlt] || m_picking) if (App::I->keys[(int)kKey::KeyAlt] || m_picking)
{ {
m_picking = true; m_picking = true;
Canvas::I->pick_start(); Canvas::I->pick_start();
glm::vec4 pix = Canvas::I->pick_get(loc); glm::vec4 pix = Canvas::I->pick_get(loc);
Canvas::I->m_current_brush->m_tip_color = pix; Canvas::I->m_current_brush->m_tip_color = pix;
App::I.brush_update(); App::I->brush_update();
} }
else else
{ {
App::I.render_task_async([loc, pr=me->m_pressure] App::I->render_task_async([loc, pr=me->m_pressure]
{ {
Canvas::I->stroke_start({ loc, 0 }, pr); Canvas::I->stroke_start({ loc, 0 }, pr);
}); });
@@ -147,7 +147,7 @@ void CanvasModePen::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
if (m_dragging && !m_picking) if (m_dragging && !m_picking)
{ {
node->mouse_release(); node->mouse_release();
App::I.render_task_async([] App::I->render_task_async([]
{ {
Canvas::I->stroke_end(); Canvas::I->stroke_end();
}); });
@@ -157,19 +157,19 @@ void CanvasModePen::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
node->mouse_release(); node->mouse_release();
glm::vec4 pix = Canvas::I->pick_get(loc); glm::vec4 pix = Canvas::I->pick_get(loc);
Canvas::I->m_current_brush->m_tip_color = pix; Canvas::I->m_current_brush->m_tip_color = pix;
App::I.brush_update(); App::I->brush_update();
Canvas::I->pick_end(); Canvas::I->pick_end();
} }
m_dragging = false; m_dragging = false;
m_picking = false; m_picking = false;
break; break;
case kEventType::MouseDownR: case kEventType::MouseDownR:
if (App::I.keys[(int)kKey::KeyAlt]) if (App::I->keys[(int)kKey::KeyAlt])
{ {
m_resizing = true; m_resizing = true;
m_dragging = true; m_dragging = true;
m_size_pos_start = m_cur_pos; m_size_pos_start = m_cur_pos;
auto curve = App::I.stroke->m_curves[App::I.stroke->m_tip_size]; auto curve = App::I->stroke->m_curves[App::I->stroke->m_tip_size];
m_size_value_start = curve.to_slider(Canvas::I->m_current_brush->m_tip_size); m_size_value_start = curve.to_slider(Canvas::I->m_current_brush->m_tip_size);
node->mouse_capture(); node->mouse_capture();
} }
@@ -185,7 +185,7 @@ void CanvasModePen::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
case kEventType::MouseMove: case kEventType::MouseMove:
if (m_dragging && !m_picking && !m_resizing) if (m_dragging && !m_picking && !m_resizing)
{ {
App::I.render_task_async([loc, pr=me->m_pressure] App::I->render_task_async([loc, pr=me->m_pressure]
{ {
Canvas::I->stroke_update({ loc, 0 }, pr); Canvas::I->stroke_update({ loc, 0 }, pr);
}); });
@@ -194,21 +194,21 @@ void CanvasModePen::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
{ {
glm::vec4 pix = Canvas::I->pick_get(loc); glm::vec4 pix = Canvas::I->pick_get(loc);
Canvas::I->m_current_brush->m_tip_color = pix; Canvas::I->m_current_brush->m_tip_color = pix;
App::I.brush_update(); App::I->brush_update();
} }
if (m_dragging && m_resizing) if (m_dragging && m_resizing)
{ {
auto diff = m_cur_pos - m_size_pos_start; auto diff = m_cur_pos - m_size_pos_start;
auto curve = App::I.stroke->m_curves[App::I.stroke->m_tip_size]; auto curve = App::I->stroke->m_curves[App::I->stroke->m_tip_size];
Canvas::I->m_current_brush->m_tip_size = glm::max(curve.to_value(m_size_value_start + diff.x * 0.001f), 0.001f); Canvas::I->m_current_brush->m_tip_size = glm::max(curve.to_value(m_size_value_start + diff.x * 0.001f), 0.001f);
App::I.brush_update(); App::I->brush_update();
} }
m_cur_pos = loc; m_cur_pos = loc;
break; break;
case kEventType::MouseCancel: case kEventType::MouseCancel:
if (m_dragging) if (m_dragging)
{ {
App::I.render_task_async([] App::I->render_task_async([]
{ {
Canvas::I->stroke_cancel(); Canvas::I->stroke_cancel();
}); });
@@ -231,14 +231,14 @@ void CanvasModePen::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const
{ {
const auto& brush = Canvas::I->m_current_brush; const auto& brush = Canvas::I->m_current_brush;
auto pos = m_resizing ? m_size_pos_start : m_cur_pos; auto pos = m_resizing ? m_size_pos_start : m_cur_pos;
//if (App::I.keys[(int)kKey::KeyAlt] && !m_resizing) //if (App::I->keys[(int)kKey::KeyAlt] && !m_resizing)
// pos.x = pos.x - brush->m_tip_size * .5f; // pos.x = pos.x - brush->m_tip_size * .5f;
ShaderManager::use(kShader::StrokePreview); ShaderManager::use(kShader::StrokePreview);
ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_float(kShaderUniform::Alpha, brush->m_tip_flow * brush->m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, brush->m_tip_flow * brush->m_tip_opacity);
float tip_scale_fix = 1.f / glm::tan(glm::radians(Canvas::I->m_cam_fov * 0.5f)); float tip_scale_fix = 1.f / glm::tan(glm::radians(Canvas::I->m_cam_fov * 0.5f));
float tip_angle = brush->m_tip_angle * (float)(M_PI * 2.0); float tip_angle = brush->m_tip_angle * (float)(M_PI * 2.0);
glm::vec2 tip_scale = App::I.zoom * brush->m_tip_scale * glm::vec2 tip_scale = App::I->zoom * brush->m_tip_scale *
glm::vec2(brush->m_tip_size * tip_scale_fix) * glm::vec2(brush->m_tip_size * tip_scale_fix) *
glm::vec2(brush->m_tip_flipx ? -1 : 1, brush->m_tip_flipy ? -1.f : 1.f) * glm::vec2(brush->m_tip_flipx ? -1 : 1, brush->m_tip_flipy ? -1.f : 1.f) *
glm::vec2((brush->m_tip_aspect <= 0.5 ? brush->m_tip_aspect * 2.f : 1.f), glm::vec2((brush->m_tip_aspect <= 0.5 ? brush->m_tip_aspect * 2.f : 1.f),
@@ -250,14 +250,14 @@ void CanvasModePen::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const
const auto& s = Canvas::I->m_current_stroke->m_prev_sample; const auto& s = Canvas::I->m_current_stroke->m_prev_sample;
if (s.size > 0.f) if (s.size > 0.f)
{ {
tip_scale = App::I.zoom * (brush->m_tip_size * tip_scale_fix) * s.scale; tip_scale = App::I->zoom * (brush->m_tip_size * tip_scale_fix) * s.scale;
tip_angle = s.angle; tip_angle = s.angle;
tip_offset = s.pos - s.origin; tip_offset = s.pos - s.origin;
tip_color = glm::vec4(s.col, s.flow); tip_color = glm::vec4(s.col, s.flow);
} }
} }
glm::u8vec4 pixel; glm::u8vec4 pixel;
glReadPixels(pos.x / App::I.zoom, (App::I.height - pos.y - 1) / App::I.zoom, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &pixel); glReadPixels(pos.x / App::I->zoom, (App::I->height - pos.y - 1) / App::I->zoom, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &pixel);
bool outline = glm::min(tip_scale.x, tip_scale.y) < 20 || m_resizing ? false : m_draw_outline; bool outline = glm::min(tip_scale.x, tip_scale.y) < 20 || m_resizing ? false : m_draw_outline;
ShaderManager::u_int(kShaderUniform::DrawOutline, outline); ShaderManager::u_int(kShaderUniform::DrawOutline, outline);
ShaderManager::u_vec4(kShaderUniform::Col, outline ? glm::vec4(1.f - glm::vec3(pixel) / 255.f, 1.f) : tip_color); ShaderManager::u_vec4(kShaderUniform::Col, outline ? glm::vec4(1.f - glm::vec3(pixel) / 255.f, 1.f) : tip_color);
@@ -312,7 +312,7 @@ void CanvasModeLine::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
node->mouse_release(); node->mouse_release();
if (m_dragging) if (m_dragging)
{ {
App::I.render_task_async([=] App::I->render_task_async([=]
{ {
Canvas::I->stroke_start({ m_drag_start, 0 }, 1.f); Canvas::I->stroke_start({ m_drag_start, 0 }, 1.f);
Canvas::I->stroke_update({ m_drag_pos, 0 }, 1.f); Canvas::I->stroke_update({ m_drag_pos, 0 }, 1.f);
@@ -359,7 +359,7 @@ void CanvasModeLine::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
ShaderManager::u_float(kShaderUniform::Alpha, brush->m_tip_flow * brush->m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, brush->m_tip_flow * brush->m_tip_opacity);
float tip_scale_fix = 1.f / glm::tan(glm::radians(Canvas::I->m_cam_fov * 0.5f)); float tip_scale_fix = 1.f / glm::tan(glm::radians(Canvas::I->m_cam_fov * 0.5f));
float tip_angle = brush->m_tip_angle * (float)(M_PI * 2.0); float tip_angle = brush->m_tip_angle * (float)(M_PI * 2.0);
glm::vec2 tip_scale = App::I.zoom * brush->m_tip_scale * glm::vec2 tip_scale = App::I->zoom * brush->m_tip_scale *
glm::vec2(brush->m_tip_size * tip_scale_fix) * glm::vec2(brush->m_tip_size * tip_scale_fix) *
glm::vec2(brush->m_tip_flipx ? -1 : 1, brush->m_tip_flipy ? -1.f : 1.f) * glm::vec2(brush->m_tip_flipx ? -1 : 1, brush->m_tip_flipy ? -1.f : 1.f) *
glm::vec2((brush->m_tip_aspect <= 0.5 ? brush->m_tip_aspect * 2.f : 1.f), glm::vec2((brush->m_tip_aspect <= 0.5 ? brush->m_tip_aspect * 2.f : 1.f),
@@ -653,7 +653,7 @@ void CanvasModeMaskFree::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
m_points2d.push_back(loc); m_points2d.push_back(loc);
m_points.push_back(vert); m_points.push_back(vert);
m_points.push_back(vert); m_points.push_back(vert);
if (!(App::I.keys[(int)kKey::KeyShift] || App::I.keys[(int)kKey::KeyCtrl])) if (!(App::I->keys[(int)kKey::KeyShift] || App::I->keys[(int)kKey::KeyCtrl]))
Canvas::I->m_smask.clear({0, 0, 0, 0}); Canvas::I->m_smask.clear({0, 0, 0, 0});
Canvas::I->m_smask_active = true; Canvas::I->m_smask_active = true;
Canvas::I->m_smask_mode = 1; Canvas::I->m_smask_mode = 1;
@@ -674,7 +674,7 @@ void CanvasModeMaskFree::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
ShaderManager::use(kShader::Color); ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, ShaderManager::u_vec4(kShaderUniform::Col,
App::I.keys[(int)kKey::KeyCtrl] ? glm::vec4(0, 0, 0, 1) : glm::vec4(1, 1, 1, 1)); App::I->keys[(int)kKey::KeyCtrl] ? glm::vec4(0, 0, 0, 1) : glm::vec4(1, 1, 1, 1));
m_shape.draw_fill(); m_shape.draw_fill();
}; };
// use m_shape to render the mask polygon // use m_shape to render the mask polygon
@@ -1072,7 +1072,7 @@ void CanvasModeTransform::enter(kCanvasMode prev)
} }
auto center = zw(Canvas::I->m_box) * 0.5f; auto center = zw(Canvas::I->m_box) * 0.5f;
glm::vec2 bb_sz = glm::vec2(aspect, 1.f) * 100.f * App::I.zoom; glm::vec2 bb_sz = glm::vec2(aspect, 1.f) * 100.f * App::I->zoom;
glm::vec2 bb_min = center - bb_sz * 0.5f; glm::vec2 bb_min = center - bb_sz * 0.5f;
glm::vec2 bb_max = center + bb_sz * 0.5f; glm::vec2 bb_max = center + bb_sz * 0.5f;
glm::vec2 midpoint = (bb_min + bb_max) * 0.5f; glm::vec2 midpoint = (bb_min + bb_max) * 0.5f;
@@ -1207,7 +1207,7 @@ void CanvasModeTransform::enter(kCanvasMode prev)
auto shape3d = triangulate(m_points_face[plane]); auto shape3d = triangulate(m_points_face[plane]);
App::I.render_task([&] App::I->render_task([&]
{ {
m_shape[plane].update_vertices(shape3d.data(), (int)shape3d.size()); m_shape[plane].update_vertices(shape3d.data(), (int)shape3d.size());
Canvas::I->m_layers[Canvas::I->m_current_layer_idx]->m_rtt[plane].bindFramebuffer(); Canvas::I->m_layers[Canvas::I->m_current_layer_idx]->m_rtt[plane].bindFramebuffer();
@@ -1269,7 +1269,7 @@ void CanvasModeTransform::enter(kCanvasMode prev)
glm::max(zw(layer->m_dirty_box[i]), bb_max), glm::max(zw(layer->m_dirty_box[i]), bb_max),
}; };
App::I.render_task([&] App::I->render_task([&]
{ {
glViewport(0, 0, layer->w, layer->h); glViewport(0, 0, layer->w, layer->h);
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
@@ -1367,7 +1367,7 @@ void CanvasModeTransform::leave(kCanvasMode next)
glm::max(zw(layer->m_dirty_box[i]), bb_max), glm::max(zw(layer->m_dirty_box[i]), bb_max),
}; };
App::I.render_task([&] App::I->render_task([&]
{ {
layer->m_rtt[i].bindFramebuffer(); layer->m_rtt[i].bindFramebuffer();
@@ -1451,7 +1451,7 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
auto c2d = (xy(c3d) * 0.5f + 0.5f) * zw(Canvas::I->m_box); auto c2d = (xy(c3d) * 0.5f + 0.5f) * zw(Canvas::I->m_box);
ShaderManager::u_mat4(kShaderUniform::MVP, ShaderManager::u_mat4(kShaderUniform::MVP,
ortho * glm::translate(glm::vec3(c2d, 0)) * glm::scale(glm::vec3(20.f) * App::I.zoom)); ortho * glm::translate(glm::vec3(c2d, 0)) * glm::scale(glm::vec3(20.f) * App::I->zoom));
// draw inside // draw inside
ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, i == corner_hl ? 1.f : .1f }); ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, i == corner_hl ? 1.f : .1f });
@@ -1488,7 +1488,7 @@ void CanvasModeTransform::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
auto c = m2d * glm::vec4(corners[i], 1); auto c = m2d * glm::vec4(corners[i], 1);
corners2d[i] = ((xy(c) / c.z) * 0.5f + 0.5f) * zw(Canvas::I->m_box); corners2d[i] = ((xy(c) / c.z) * 0.5f + 0.5f) * zw(Canvas::I->m_box);
float d = glm::distance(corners2d[i], loc); float d = glm::distance(corners2d[i], loc);
if (d < 20.f * App::I.zoom) if (d < 20.f * App::I->zoom)
corner_hl = i; corner_hl = i;
} }
if (corner_hl != -1) if (corner_hl != -1)
@@ -1514,7 +1514,7 @@ void CanvasModeTransform::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
auto c = m2d * glm::vec4(corners[i], 1); auto c = m2d * glm::vec4(corners[i], 1);
corners2d[i] = ((xy(c) / c.z) * 0.5f + 0.5f) * zw(Canvas::I->m_box); corners2d[i] = ((xy(c) / c.z) * 0.5f + 0.5f) * zw(Canvas::I->m_box);
float d = glm::distance(corners2d[i], loc); float d = glm::distance(corners2d[i], loc);
if (d < 20.f * App::I.zoom) if (d < 20.f * App::I->zoom)
corner_hl = i; corner_hl = i;
} }
if (m_dragging) if (m_dragging)
@@ -1683,7 +1683,7 @@ void CanvasModeFloodFill::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
void CanvasModeFloodFill::enter(kCanvasMode prev) void CanvasModeFloodFill::enter(kCanvasMode prev)
{ {
auto tools = App::I.layout[App::I.main_id]->find("tools-container"); auto tools = App::I->layout[App::I->main_id]->find("tools-container");
m_tool = tools->add_child<NodeToolBucket>(); m_tool = tools->add_child<NodeToolBucket>();
} }

4
src/font.cpp
View File

@@ -60,7 +60,7 @@ const Font& FontManager::get(kFont id)
bool TextMesh::create() bool TextMesh::create()
{ {
App::I.render_task([this] App::I->render_task([this]
{ {
glGenBuffers(2, font_buffers); glGenBuffers(2, font_buffers);
#if USE_VBO #if USE_VBO
@@ -125,7 +125,7 @@ void TextMesh::update(kFont id, const char* text)
vi -= glm::vec4(bbmin, 0, 0); vi -= glm::vec4(bbmin, 0, 0);
bb = bbmax - bbmin; bb = bbmax - bbmin;
font_array_count = (int)idx.size(); font_array_count = (int)idx.size();
App::I.render_task([&] App::I->render_task([&]
{ {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, font_buffers[1]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, font_buffers[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, idx.size() * sizeof(GLushort), idx.data(), GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, idx.size() * sizeof(GLushort), idx.data(), GL_STATIC_DRAW);

2
src/log.cpp
View File

@@ -75,7 +75,7 @@ void LogRemote::net_close()
void LogRemote::file_init() void LogRemote::file_init()
{ {
if (!m_logfile.is_open()) if (!m_logfile.is_open())
m_logfile.open(App::I.data_path + "/panopainter-log.txt"); m_logfile.open(App::I->data_path + "/panopainter-log.txt");
} }
void LogRemote::file_close() void LogRemote::file_close()
{ {

144
src/main.cpp
View File

@@ -174,24 +174,24 @@ void win32_update_stylus(float dt)
{ {
WacomTablet::I.m_stylus = false; WacomTablet::I.m_stylus = false;
WacomTablet::I.m_eraser = false; WacomTablet::I.m_eraser = false;
App::I.redraw = true; App::I->redraw = true;
} }
if (timer_ink_pen > 0.1 && WacomTablet::I.m_ink_pen) if (timer_ink_pen > 0.1 && WacomTablet::I.m_ink_pen)
{ {
WacomTablet::I.m_ink_pen = false; WacomTablet::I.m_ink_pen = false;
App::I.redraw = true; App::I->redraw = true;
} }
if (timer_ink_touch > 0.1 && WacomTablet::I.m_ink_touch) if (timer_ink_touch > 0.1 && WacomTablet::I.m_ink_touch)
{ {
WacomTablet::I.m_ink_touch = false; WacomTablet::I.m_ink_touch = false;
App::I.redraw = true; App::I->redraw = true;
} }
} }
void win32_update_fps(int frames) void win32_update_fps(int frames)
{ {
static wchar_t title_fps[512]; static wchar_t title_fps[512];
if (App::I.vr_active) if (App::I->vr_active)
swprintf_s(title_fps, L"%s - %d fps - %d vr fps", window_title, frames, vr_frames); swprintf_s(title_fps, L"%s - %d fps - %d vr fps", window_title, frames, vr_frames);
else else
swprintf_s(title_fps, L"%s - %d fps", window_title, frames); swprintf_s(title_fps, L"%s - %d fps", window_title, frames);
@@ -514,7 +514,7 @@ static void SetupExceptionHandler()
// PCTSTR pszLogFileName = BT_GetLogFileName(g_iLogHandle); // PCTSTR pszLogFileName = BT_GetLogFileName(g_iLogHandle);
TCHAR wpath[MAX_PATH]; TCHAR wpath[MAX_PATH];
//GetFullPathNameW(L"panopainter-log.txt", 1024, wpath, nullptr); //GetFullPathNameW(L"panopainter-log.txt", 1024, wpath, nullptr);
auto log_file = App::I.data_path + "/panopainter-log.txt"; auto log_file = App::I->data_path + "/panopainter-log.txt";
std::mbstowcs(wpath, log_file.c_str(), log_file.size()); std::mbstowcs(wpath, log_file.c_str(), log_file.size());
BT_AddLogFile(wpath); BT_AddLogFile(wpath);
@@ -526,7 +526,7 @@ static void SetupExceptionHandler()
std::ostringstream oss; std::ostringstream oss;
oss << std::put_time(&tm, "%d-%m-%Y %H-%M-%S"); oss << std::put_time(&tm, "%d-%m-%Y %H-%M-%S");
auto path = App::I.data_path + "/" + App::I.doc_name + "-recovery (" + oss.str() + ").ppi"; auto path = App::I->data_path + "/" + App::I->doc_name + "-recovery (" + oss.str() + ").ppi";
Canvas::I->project_save_thread(path); Canvas::I->project_save_thread(path);
static char abspath[MAX_PATH]; static char abspath[MAX_PATH];
GetFullPathNameA(path.c_str(), MAX_PATH, abspath, NULL); GetFullPathNameA(path.c_str(), MAX_PATH, abspath, NULL);
@@ -570,7 +570,7 @@ bool win32_vr_start()
return false; return false;
vive = new Vive; vive = new Vive;
vive->on_draw = [](const glm::mat4& proj, const glm::mat4& view, const glm::mat4& pose) { App::I.vr_draw(proj, view, pose); }; vive->on_draw = [](const glm::mat4& proj, const glm::mat4& view, const glm::mat4& pose) { App::I->vr_draw(proj, view, pose); };
if (!vive->Initialize()) if (!vive->Initialize())
{ {
delete vive; delete vive;
@@ -585,12 +585,12 @@ bool win32_vr_start()
BT_SetTerminate(); BT_SetTerminate();
LOG("start hmd render thread"); LOG("start hmd render thread");
App::I.has_vr = true; App::I->has_vr = true;
vr_running = true; vr_running = true;
vive->on_analog_button = std::bind(&App::vr_analog, &App::I, std::placeholders::_1, vive->on_analog_button = std::bind(&App::vr_analog, App::I, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3, std::placeholders::_4); std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
vive->on_button = std::bind(&App::vr_digital, &App::I, std::placeholders::_1, vive->on_button = std::bind(&App::vr_digital, App::I, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3, std::placeholders::_4); std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
const float target_tick_rate = 90; const float target_tick_rate = 90;
@@ -613,10 +613,10 @@ bool win32_vr_start()
frames++; frames++;
vive->Update(); vive->Update();
App::I.vr_active = vive->m_active; App::I->vr_active = vive->m_active;
App::I.vr_controllers[0] = vive->m_controllers[0]; App::I->vr_controllers[0] = vive->m_controllers[0];
App::I.vr_head = vive->m_pose; App::I->vr_head = vive->m_pose;
App::I.vr_update(dt); App::I->vr_update(dt);
if (vr_running && vive->m_active) if (vr_running && vive->m_active)
{ {
@@ -630,8 +630,8 @@ bool win32_vr_start()
hmd_render_cv.wait_for(lock, std::chrono::milliseconds(diff)); hmd_render_cv.wait_for(lock, std::chrono::milliseconds(diff));
t0 = t1; t0 = t1;
} }
App::I.vr_active = false; App::I->vr_active = false;
App::I.has_vr = false; App::I->has_vr = false;
vr_running = false; vr_running = false;
if (async_lock_try()) if (async_lock_try())
{ {
@@ -757,7 +757,7 @@ BOOL UnadjustWindowRectEx(LPRECT prc, DWORD dwStyle, BOOL fMenu, DWORD dwExStyle
void _pre_call_callback(const char* name, void* funcptr, int len_args, ...) void _pre_call_callback(const char* name, void* funcptr, int len_args, ...)
{ {
assert(App::I.is_render_thread()); assert(App::I->is_render_thread());
} }
void _post_call_callback(const char* name, void* funcptr, int len_args, ...) void _post_call_callback(const char* name, void* funcptr, int len_args, ...)
@@ -776,7 +776,8 @@ int main(int argc, char** argv)
WNDCLASS wc; WNDCLASS wc;
PIXELFORMATDESCRIPTOR pfd; PIXELFORMATDESCRIPTOR pfd;
App::I.initLog(); App::I = new App();
App::I->initLog();
init_shcore_API(); init_shcore_API();
init_ink_API(); init_ink_API();
@@ -811,7 +812,7 @@ int main(int argc, char** argv)
read_WMI_info(); read_WMI_info();
App::I.create(); App::I->create();
// Inizialize data structures to zero // Inizialize data structures to zero
memset(&wc, 0, sizeof(wc)); memset(&wc, 0, sizeof(wc));
@@ -836,7 +837,7 @@ int main(int argc, char** argv)
auto y = unsigned{96}; auto y = unsigned{96};
if (GetDpiForMonitor_fn) if (GetDpiForMonitor_fn)
GetDpiForMonitor_fn(monitor, MDT_EFFECTIVE_DPI, &x, &y); GetDpiForMonitor_fn(monitor, MDT_EFFECTIVE_DPI, &x, &y);
App::I.zoom *= (float)x / 96.f; App::I->zoom *= (float)x / 96.f;
int show_cmd = SW_NORMAL; int show_cmd = SW_NORMAL;
Settings::value<Serializer::Integer>("window-show-cmd", show_cmd); Settings::value<Serializer::Integer>("window-show-cmd", show_cmd);
@@ -844,13 +845,13 @@ int main(int argc, char** argv)
//if (show_cmd == SW_MAXIMIZE) //if (show_cmd == SW_MAXIMIZE)
// wnd_style != WS_MAXIMIZE; // wnd_style != WS_MAXIMIZE;
RECT clientRect = { 0, 0, (int)App::I.width * App::I.zoom, (int)App::I.height * App::I.zoom }; RECT clientRect = { 0, 0, (int)App::I->width * App::I->zoom, (int)App::I->height * App::I->zoom };
POINT clientPos = { CW_USEDEFAULT, CW_USEDEFAULT }; POINT clientPos = { CW_USEDEFAULT, CW_USEDEFAULT };
if (Settings::has("window-rect")) if (Settings::has("window-rect"))
{ {
auto wnd_rect = Settings::value<Serializer::IVec4>("window-rect"); auto wnd_rect = Settings::value<Serializer::IVec4>("window-rect");
App::I.width = wnd_rect.z - wnd_rect.x; App::I->width = wnd_rect.z - wnd_rect.x;
App::I.height = wnd_rect.w - wnd_rect.y; App::I->height = wnd_rect.w - wnd_rect.y;
clientRect = { wnd_rect.x, wnd_rect.y, wnd_rect.z, wnd_rect.w }; clientRect = { wnd_rect.x, wnd_rect.y, wnd_rect.z, wnd_rect.w };
clientPos = { wnd_rect.x, wnd_rect.y }; clientPos = { wnd_rect.x, wnd_rect.y };
} }
@@ -952,8 +953,8 @@ int main(int argc, char** argv)
switch (const_hash(argv[1])) switch (const_hash(argv[1]))
{ {
case const_hash("convert"): case const_hash("convert"):
App::I.initShaders(); App::I->initShaders();
App::I.cmd_convert(argv[2], argv[3]); App::I->cmd_convert(argv[2], argv[3]);
return 0; return 0;
case const_hash("-vrmode"): case const_hash("-vrmode"):
start_in_vr = true; start_in_vr = true;
@@ -972,8 +973,8 @@ int main(int argc, char** argv)
wglMakeCurrent(NULL, NULL); wglMakeCurrent(NULL, NULL);
running = 1; running = 1;
App::I.render_thread_start(); App::I->render_thread_start();
App::I.ui_thread_start(); App::I->ui_thread_start();
#ifdef _DEBUG #ifdef _DEBUG
glad_set_pre_callback(_pre_call_callback); glad_set_pre_callback(_pre_call_callback);
@@ -994,7 +995,7 @@ int main(int argc, char** argv)
SendMessage(hWnd, WM_SETICON, ICON_SMALL, SendMessage(hWnd, WM_SETICON, ICON_SMALL,
(LPARAM)LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(IDI_ICON1))); (LPARAM)LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(IDI_ICON1)));
App::I.ui_sync(); App::I->ui_sync();
{ {
WINDOWPLACEMENT wp; WINDOWPLACEMENT wp;
@@ -1002,12 +1003,12 @@ int main(int argc, char** argv)
wp.showCmd = show_cmd; wp.showCmd = show_cmd;
SetWindowPlacement(hWnd, &wp); SetWindowPlacement(hWnd, &wp);
//GetClientRect(hWnd, &clientRect); //GetClientRect(hWnd, &clientRect);
//App::I.width = clientRect.right - clientRect.left; //App::I->width = clientRect.right - clientRect.left;
//App::I.height = clientRect.bottom - clientRect.top; //App::I->height = clientRect.bottom - clientRect.top;
} }
if (start_in_vr) if (start_in_vr)
App::I.vr_start(); App::I->vr_start();
LOG("show main window"); LOG("show main window");
SetForegroundWindow(hWnd); SetForegroundWindow(hWnd);
@@ -1022,7 +1023,7 @@ int main(int argc, char** argv)
while (running == 1) while (running == 1)
{ {
// If there any message in the queue process it // If there any message in the queue process it
auto present = App::I.animate || App::I.redraw ? auto present = App::I->animate || App::I->redraw ?
PeekMessage(&msg, 0, 0, 0, PM_REMOVE) : GetMessage(&msg, 0, 0, 0); PeekMessage(&msg, 0, 0, 0, PM_REMOVE) : GetMessage(&msg, 0, 0, 0);
if (msg.message == WM_QUIT) if (msg.message == WM_QUIT)
@@ -1075,21 +1076,22 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
running = 0; running = 0;
if (hmd_renderer.joinable()) if (hmd_renderer.joinable())
hmd_renderer.join(); hmd_renderer.join();
App::I.ui_thread_stop(); App::I->ui_thread_stop();
App::I.render_thread_stop(); App::I->render_thread_stop();
App::I.terminate(); App::I->terminate();
delete App::I;
PostQuitMessage(0); PostQuitMessage(0);
return 0; return 0;
case WM_PAINT: case WM_PAINT:
App::I.redraw = true; App::I->redraw = true;
break; break;
case WM_CREATE: case WM_CREATE:
BT_SetTerminate(); BT_SetTerminate();
break; break;
case WM_CLOSE: case WM_CLOSE:
{ {
App::I.ui_task_async([] { App::I->ui_task_async([] {
if (App::I.request_close()) if (App::I->request_close())
{ {
destroy_window(); destroy_window();
} }
@@ -1103,17 +1105,17 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
auto h = (float)HIWORD(lp); auto h = (float)HIWORD(lp);
if (h != 0 && running == 1) if (h != 0 && running == 1)
{ {
App::I.ui_task_async([=] App::I->ui_task_async([=]
{ {
App::I.resize(w, h); App::I->resize(w, h);
App::I.redraw = true; App::I->redraw = true;
}); });
} }
break; break;
} }
case WM_ACTIVATE: case WM_ACTIVATE:
{ {
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
int active = GET_WM_ACTIVATE_STATE(wp, lp); int active = GET_WM_ACTIVATE_STATE(wp, lp);
WacomTablet::I.set_focus(active); WacomTablet::I.set_focus(active);
static BYTE keys[256]; static BYTE keys[256];
@@ -1126,10 +1128,10 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
if (alt && k.first == kKey::KeyTab) if (alt && k.first == kKey::KeyTab)
continue; continue;
bool down = keys[k.second] & 0x80; bool down = keys[k.second] & 0x80;
if (App::I.keys[(int)k.first] && !down) if (App::I->keys[(int)k.first] && !down)
App::I.key_up(k.first); App::I->key_up(k.first);
else if(!App::I.keys[(int)k.first] && down) else if(!App::I->keys[(int)k.first] && down)
App::I.key_down(k.first); App::I->key_down(k.first);
} }
} }
}); });
@@ -1137,16 +1139,16 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
} }
// case WM_TOUCH: // case WM_TOUCH:
// { // {
// App::I.ui_task_async([=] { // App::I->ui_task_async([=] {
// //LOG("touch"); // //LOG("touch");
// }); // });
// break; // break;
// } // }
case WT_PACKET: case WT_PACKET:
{ {
App::I.set_stylus(); App::I->set_stylus();
timer_stylus = 0; timer_stylus = 0;
App::I.ui_task_async([=] { App::I->ui_task_async([=] {
WacomTablet::I.handle_message(hWnd, msg, wp, lp); WacomTablet::I.handle_message(hWnd, msg, wp, lp);
}); });
break; break;
@@ -1154,26 +1156,26 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
case WM_SYSKEYDOWN: case WM_SYSKEYDOWN:
case WM_KEYDOWN: case WM_KEYDOWN:
if ((lp >> 30 & 1) == 0 && // ignore repeated if ((lp >> 30 & 1) == 0 && // ignore repeated
!(wp == VK_TAB && App::I.keys[(int)kKey::KeyAlt])) // ignore alt+tab !(wp == VK_TAB && App::I->keys[(int)kKey::KeyAlt])) // ignore alt+tab
{ {
App::I.ui_task_async([wp] { App::I->ui_task_async([wp] {
App::I.key_down(convert_key((int)wp)); App::I->key_down(convert_key((int)wp));
}); });
} }
break; break;
case WM_SYSKEYUP: case WM_SYSKEYUP:
case WM_KEYUP: case WM_KEYUP:
if (!(wp == VK_TAB && App::I.keys[(int)kKey::KeyAlt])) // ignore alt+tab if (!(wp == VK_TAB && App::I->keys[(int)kKey::KeyAlt])) // ignore alt+tab
{ {
App::I.ui_task_async([wp] { App::I->ui_task_async([wp] {
App::I.key_up(convert_key((int)wp)); App::I->key_up(convert_key((int)wp));
}); });
} }
break; break;
case WM_CHAR: case WM_CHAR:
{ {
App::I.ui_task_async([wp]{ App::I->ui_task_async([wp]{
App::I.key_char((int)wp); App::I->key_char((int)wp);
}); });
} }
break; break;
@@ -1188,7 +1190,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
SetCursorPos(center.x, center.y); SetCursorPos(center.x, center.y);
//glm::vec2 cur = { GET_X_LPARAM(lp), GET_Y_LPARAM(lp) }; //glm::vec2 cur = { GET_X_LPARAM(lp), GET_Y_LPARAM(lp) };
glm::vec2 sz = { App::I.width, App::I.height }; glm::vec2 sz = { App::I->width, App::I->height };
glm::vec2 diff = { curpos.x - center.x, curpos.y - center.y }; glm::vec2 diff = { curpos.x - center.x, curpos.y - center.y };
lastPoint = glm::clamp(lastPoint + diff, { 0, 0 }, sz); lastPoint = glm::clamp(lastPoint + diff, { 0, 0 }, sz);
@@ -1196,7 +1198,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
lastPoint = { GET_X_LPARAM(lp), GET_Y_LPARAM(lp) }; lastPoint = { GET_X_LPARAM(lp), GET_Y_LPARAM(lp) };
auto pt = lastPoint; auto pt = lastPoint;
App::I.ui_task_async([pt, extra, p = WacomTablet::I.get_pressure()]{ App::I->ui_task_async([pt, extra, p = WacomTablet::I.get_pressure()]{
kEventSource pointer_source; kEventSource pointer_source;
if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch) if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch)
{ {
@@ -1208,7 +1210,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
if ((extra & 0xFFFFFF00) == 0xFF515700) if ((extra & 0xFFFFFF00) == 0xFF515700)
pointer_source = kEventSource::Touch; pointer_source = kEventSource::Touch;
} }
App::I.mouse_move((float)pt.x, (float)pt.y, p, pointer_source, WacomTablet::I.m_eraser); App::I->mouse_move((float)pt.x, (float)pt.y, p, pointer_source, WacomTablet::I.m_eraser);
}); });
} }
break; break;
@@ -1216,7 +1218,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
{ {
SetCapture(hWnd); SetCapture(hWnd);
auto pt = lastPoint; auto pt = lastPoint;
App::I.ui_task_async([pt, extra, hWnd, p = WacomTablet::I.get_pressure()]{ App::I->ui_task_async([pt, extra, hWnd, p = WacomTablet::I.get_pressure()]{
kEventSource pointer_source; kEventSource pointer_source;
if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch) if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch)
{ {
@@ -1228,7 +1230,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
if ((extra & 0xFFFFFF00) == 0xFF515700) if ((extra & 0xFFFFFF00) == 0xFF515700)
pointer_source = kEventSource::Touch; pointer_source = kEventSource::Touch;
} }
App::I.mouse_down(0, (float)pt.x, (float)pt.y, p, pointer_source, WacomTablet::I.m_eraser); App::I->mouse_down(0, (float)pt.x, (float)pt.y, p, pointer_source, WacomTablet::I.m_eraser);
}); });
} }
break; break;
@@ -1236,7 +1238,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
{ {
ReleaseCapture(); ReleaseCapture();
auto pt = lastPoint; auto pt = lastPoint;
App::I.ui_task_async([pt, extra] { App::I->ui_task_async([pt, extra] {
WacomTablet::I.reset_pressure(); WacomTablet::I.reset_pressure();
kEventSource pointer_source; kEventSource pointer_source;
if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch) if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch)
@@ -1249,7 +1251,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
if ((extra & 0xFFFFFF00) == 0xFF515700) if ((extra & 0xFFFFFF00) == 0xFF515700)
pointer_source = kEventSource::Touch; pointer_source = kEventSource::Touch;
} }
App::I.mouse_up(0, (float)pt.x, (float)pt.y, pointer_source, WacomTablet::I.m_eraser); App::I->mouse_up(0, (float)pt.x, (float)pt.y, pointer_source, WacomTablet::I.m_eraser);
}); });
} }
break; break;
@@ -1257,7 +1259,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
{ {
SetCapture(hWnd); SetCapture(hWnd);
auto pt = lastPoint; auto pt = lastPoint;
App::I.ui_task_async([pt, extra, hWnd] { App::I->ui_task_async([pt, extra, hWnd] {
kEventSource pointer_source; kEventSource pointer_source;
if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch) if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch)
{ {
@@ -1269,7 +1271,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
if ((extra & 0xFFFFFF00) == 0xFF515700) if ((extra & 0xFFFFFF00) == 0xFF515700)
pointer_source = kEventSource::Touch; pointer_source = kEventSource::Touch;
} }
App::I.mouse_down(1, (float)pt.x, (float)pt.y, 1.f, pointer_source, 0); App::I->mouse_down(1, (float)pt.x, (float)pt.y, 1.f, pointer_source, 0);
}); });
} }
break; break;
@@ -1277,7 +1279,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
{ {
ReleaseCapture(); ReleaseCapture();
auto pt = lastPoint; auto pt = lastPoint;
App::I.ui_task_async([pt, extra] { App::I->ui_task_async([pt, extra] {
kEventSource pointer_source; kEventSource pointer_source;
if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch) if (WacomTablet::I.m_ink_pen || WacomTablet::I.m_ink_touch)
{ {
@@ -1289,7 +1291,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
if ((extra & 0xFFFFFF00) == 0xFF515700) if ((extra & 0xFFFFFF00) == 0xFF515700)
pointer_source = kEventSource::Touch; pointer_source = kEventSource::Touch;
} }
App::I.mouse_up(1, (float)pt.x, (float)pt.y, pointer_source, 0); App::I->mouse_up(1, (float)pt.x, (float)pt.y, pointer_source, 0);
}); });
} }
break; break;
@@ -1300,8 +1302,8 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
pt.y = GET_Y_LPARAM(lp); pt.y = GET_Y_LPARAM(lp);
ScreenToClient(hWnd, &pt); ScreenToClient(hWnd, &pt);
{ {
App::I.ui_task_async([pt, wp] { App::I->ui_task_async([pt, wp] {
App::I.mouse_scroll((float)pt.x, (float)pt.y, App::I->mouse_scroll((float)pt.x, (float)pt.y,
(float)GET_WHEEL_DELTA_WPARAM(wp) / (float)WHEEL_DELTA); (float)GET_WHEEL_DELTA_WPARAM(wp) / (float)WHEEL_DELTA);
}); });
} }
@@ -1365,7 +1367,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
timer_ink_pen = 0; timer_ink_pen = 0;
WacomTablet::I.m_ink_pen = true; WacomTablet::I.m_ink_pen = true;
WacomTablet::I.m_pen_pres = (float)penInfo.pressure / 1024.f; WacomTablet::I.m_pen_pres = (float)penInfo.pressure / 1024.f;
App::I.set_stylus(); App::I->set_stylus();
} }
break; break;
default: default:

26
src/node.cpp
View File

@@ -39,8 +39,8 @@
void Node::app_redraw() void Node::app_redraw()
{ {
App::I.redraw = true; App::I->redraw = true;
App::I.ui_cv.notify_all(); App::I->ui_cv.notify_all();
} }
void Node::watch(std::function<bool(Node*)> observer) void Node::watch(std::function<bool(Node*)> observer)
@@ -303,7 +303,7 @@ void Node::removed(Node* parent)
const Node* Node::init_template(const char* id) const Node* Node::init_template(const char* id)
{ {
Node* m_template = nullptr; Node* m_template = nullptr;
App::I.ui_task([&] App::I->ui_task([&]
{ {
auto hid = const_hash(id); auto hid = const_hash(id);
Node* top = m_manager->get(hid); Node* top = m_manager->get(hid);
@@ -324,7 +324,7 @@ const Node* Node::init_template(const char* id)
void Node::add_child(Node* n) void Node::add_child(Node* n)
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
if (n->m_parent) if (n->m_parent)
n->m_parent->remove_child(n); n->m_parent->remove_child(n);
@@ -339,7 +339,7 @@ void Node::add_child(Node* n)
void Node::add_child(Node* n, int index) void Node::add_child(Node* n, int index)
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
if (n->m_parent) if (n->m_parent)
n->m_parent->remove_child(n); n->m_parent->remove_child(n);
@@ -354,7 +354,7 @@ void Node::add_child(Node* n, int index)
void Node::add_child(std::shared_ptr<Node> n) void Node::add_child(std::shared_ptr<Node> n)
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
if (n->m_parent) if (n->m_parent)
n->m_parent->remove_child(n.get()); n->m_parent->remove_child(n.get());
@@ -369,7 +369,7 @@ void Node::add_child(std::shared_ptr<Node> n)
void Node::add_child(std::shared_ptr<Node> n, int index) void Node::add_child(std::shared_ptr<Node> n, int index)
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
if (n->m_parent) if (n->m_parent)
n->m_parent->remove_child(n.get()); n->m_parent->remove_child(n.get());
@@ -393,7 +393,7 @@ void Node::remove_child(Node* n)
auto i = std::find_if(m_children.begin(), m_children.end(), [=](auto& ptr) { return ptr.get() == n; }); auto i = std::find_if(m_children.begin(), m_children.end(), [=](auto& ptr) { return ptr.get() == n; });
if (i != m_children.end()) if (i != m_children.end())
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
n->removed(this); n->removed(this);
n->m_parent = nullptr; n->m_parent = nullptr;
@@ -408,7 +408,7 @@ void Node::remove_child(Node* n)
void Node::remove_all_children() void Node::remove_all_children()
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
for (auto& n : m_children) for (auto& n : m_children)
{ {
@@ -424,7 +424,7 @@ void Node::remove_all_children()
void Node::move_child(Node* n, int index) void Node::move_child(Node* n, int index)
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
YGNodeRemoveChild(y_node, n->y_node); YGNodeRemoveChild(y_node, n->y_node);
YGNodeInsertChild(y_node, n->y_node, index); YGNodeInsertChild(y_node, n->y_node, index);
@@ -438,7 +438,7 @@ void Node::move_child(Node* n, int index)
void Node::move_child_front(Node* n) void Node::move_child_front(Node* n)
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
int count = YGNodeGetChildCount(y_node); int count = YGNodeGetChildCount(y_node);
move_child(n, count - 1); move_child(n, count - 1);
@@ -447,7 +447,7 @@ void Node::move_child_front(Node* n)
void Node::move_child_offset(Node* n, int offset) void Node::move_child_offset(Node* n, int offset)
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
int count = YGNodeGetChildCount(y_node); int count = YGNodeGetChildCount(y_node);
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
@@ -879,7 +879,7 @@ void Node::SetRTL(YGDirection dir)
void Node::SetVisibility(bool visible) void Node::SetVisibility(bool visible)
{ {
App::I.ui_task([&] App::I->ui_task([&]
{ {
if (m_display && !visible) if (m_display && !visible)
{ {

32
src/node_canvas.cpp
View File

@@ -121,7 +121,7 @@ void NodeCanvas::draw()
{ {
glClearColor(1, 1, 1, 0); glClearColor(1, 1, 1, 0);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
glViewport(c.x + App::I.off_x, c.y + App::I.off_y, c.z, c.w); glViewport(c.x + App::I->off_x, c.y + App::I->off_y, c.z, c.w);
} }
// NOTE: draw_merge has been disabled for worst performance // NOTE: draw_merge has been disabled for worst performance
@@ -481,7 +481,7 @@ void NodeCanvas::draw()
for (auto& mode : Canvas::modes[(int)kCanvasMode::Grid]) for (auto& mode : Canvas::modes[(int)kCanvasMode::Grid])
mode->on_Draw(ortho_proj, proj, camera); mode->on_Draw(ortho_proj, proj, camera);
App::I.grid->draw_heightmap(proj, camera, false); App::I->grid->draw_heightmap(proj, camera, false);
for (auto& mode : *m_canvas->m_mode) for (auto& mode : *m_canvas->m_mode)
mode->on_Draw(ortho_proj, proj, camera); mode->on_Draw(ortho_proj, proj, camera);
@@ -492,7 +492,7 @@ void NodeCanvas::draw()
glClearColor(1, 1, 1, 0); glClearColor(1, 1, 1, 0);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
glViewport(c.x + App::I.off_x, c.y + App::I.off_y, c.z, c.w); glViewport(c.x + App::I->off_x, c.y + App::I->off_y, c.z, c.w);
// draw the canvas // draw the canvas
m_sampler_nearest.bind(0); m_sampler_nearest.bind(0);
@@ -567,12 +567,12 @@ kEventResult NodeCanvas::handle_event(Event* e)
break; break;
case kEventType::MouseUnfocus: case kEventType::MouseUnfocus:
(*m_canvas->m_mode)[0]->m_draw_tip = false; (*m_canvas->m_mode)[0]->m_draw_tip = false;
App::I.show_cursor(); App::I->show_cursor();
break; break;
case kEventType::MouseFocus: case kEventType::MouseFocus:
(*m_canvas->m_mode)[0]->hide_curor && (*m_canvas->m_mode)[0]->hide_curor &&
!App::I.keys[(int)kKey::KeyAlt] ? !App::I->keys[(int)kKey::KeyAlt] ?
App::I.hide_cursor() : App::I.show_cursor(); App::I->hide_cursor() : App::I->show_cursor();
break; break;
case kEventType::KeyDown: case kEventType::KeyDown:
if (ke->m_key == kKey::KeyE) if (ke->m_key == kKey::KeyE)
@@ -581,40 +581,40 @@ kEventResult NodeCanvas::handle_event(Event* e)
if (!ActionManager::empty()) if (!ActionManager::empty())
ActionManager::undo(); ActionManager::undo();
if (ke->m_key == kKey::KeyAlt && m_mouse_focus) if (ke->m_key == kKey::KeyAlt && m_mouse_focus)
App::I.show_cursor(); App::I->show_cursor();
for (auto& mode : *m_canvas->m_mode) for (auto& mode : *m_canvas->m_mode)
mode->on_KeyEvent(ke); mode->on_KeyEvent(ke);
break; break;
case kEventType::KeyUp: case kEventType::KeyUp:
if (ke->m_key == kKey::KeyAlt && m_mouse_focus) if (ke->m_key == kKey::KeyAlt && m_mouse_focus)
(*m_canvas->m_mode)[0]->hide_curor ? (*m_canvas->m_mode)[0]->hide_curor ?
App::I.hide_cursor() : App::I.show_cursor(); App::I->hide_cursor() : App::I->show_cursor();
if (ke->m_key == kKey::KeyE) if (ke->m_key == kKey::KeyE)
Canvas::set_mode(kCanvasMode::Draw); Canvas::set_mode(kCanvasMode::Draw);
if (ke->m_key == kKey::KeyTab) if (ke->m_key == kKey::KeyTab)
App::I.toggle_ui(); App::I->toggle_ui();
if (ke->m_key == kKey::KeyZ && App::I.keys[(int)kKey::KeyCtrl]) if (ke->m_key == kKey::KeyZ && App::I->keys[(int)kKey::KeyCtrl])
App::I.keys[(int)kKey::KeyShift] ? ActionManager::redo() : ActionManager::undo(); App::I->keys[(int)kKey::KeyShift] ? ActionManager::redo() : ActionManager::undo();
if (ke->m_key == kKey::KeyS && App::I.keys[(int)kKey::KeyCtrl] && !App::I.keys[(int)kKey::KeyShift]) if (ke->m_key == kKey::KeyS && App::I->keys[(int)kKey::KeyCtrl] && !App::I->keys[(int)kKey::KeyShift])
{ {
if (Canvas::I->m_newdoc) if (Canvas::I->m_newdoc)
{ {
App::I.dialog_save(); App::I->dialog_save();
} }
else if (Canvas::I->m_unsaved) else if (Canvas::I->m_unsaved)
{ {
Canvas::I->project_save(); Canvas::I->project_save();
} }
} }
if (ke->m_key == kKey::KeyS && App::I.keys[(int)kKey::KeyCtrl] && App::I.keys[(int)kKey::KeyShift]) if (ke->m_key == kKey::KeyS && App::I->keys[(int)kKey::KeyCtrl] && App::I->keys[(int)kKey::KeyShift])
{ {
if (Canvas::I->m_newdoc) if (Canvas::I->m_newdoc)
{ {
App::I.dialog_save(); App::I->dialog_save();
} }
else if (Canvas::I->m_unsaved) else if (Canvas::I->m_unsaved)
{ {
App::I.dialog_save_ver(); App::I->dialog_save_ver();
} }
} }
for (auto& mode : *m_canvas->m_mode) for (auto& mode : *m_canvas->m_mode)

2
src/node_colorwheel.cpp
View File

@@ -43,7 +43,7 @@ void NodeColorWheel::loaded()
vertices.push_back({{glm::cos(2.f/3.f*glm::pi<float>())*l,glm::sin(2.f/3.f*glm::pi<float>())*l,0,1},{0,0},{0,0,0,1}}); vertices.push_back({{glm::cos(2.f/3.f*glm::pi<float>())*l,glm::sin(2.f/3.f*glm::pi<float>())*l,0,1},{0,0},{0,0,0,1}});
vertices.push_back({{l,0,0,1},{1,1},{1,0,0,1}}); vertices.push_back({{l,0,0,1},{1,1},{1,0,0,1}});
App::I.render_task([&] App::I->render_task([&]
{ {
glGenBuffers(1, &buffers); glGenBuffers(1, &buffers);
glBindBuffer(GL_ARRAY_BUFFER, buffers); glBindBuffer(GL_ARRAY_BUFFER, buffers);

8
src/node_dialog_browse.cpp
View File

@@ -78,9 +78,9 @@ void NodeDialogBrowse::init_controls()
static char path_buffer[256]; static char path_buffer[256];
btn_path = find<NodeButton>("btn-path"); btn_path = find<NodeButton>("btn-path");
btn_path->on_click = [this](Node*){ btn_path->on_click = [this](Node*){
App::I.pick_dir([this](std::string path){ App::I->pick_dir([this](std::string path){
LOG("change working path to %s", path.c_str()); LOG("change working path to %s", path.c_str());
App::I.work_path = path; App::I->work_path = path;
#ifdef _WIN32 #ifdef _WIN32
GetFullPathNameA(path.c_str(), sizeof(path_buffer), path_buffer, nullptr); GetFullPathNameA(path.c_str(), sizeof(path_buffer), path_buffer, nullptr);
#else #else
@@ -94,9 +94,9 @@ void NodeDialogBrowse::init_controls()
}; };
working_path = find<NodeText>("path"); working_path = find<NodeText>("path");
#ifdef _WIN32 #ifdef _WIN32
GetFullPathNameA(App::I.work_path.c_str(), sizeof(path_buffer), path_buffer, nullptr); GetFullPathNameA(App::I->work_path.c_str(), sizeof(path_buffer), path_buffer, nullptr);
#else #else
realpath(App::I.work_path.c_str(), path_buffer); realpath(App::I->work_path.c_str(), path_buffer);
#endif #endif
working_path->set_text_format("Working dir: %s", path_buffer); working_path->set_text_format("Working dir: %s", path_buffer);
#endif #endif

2
src/node_dialog_cloud.cpp
View File

@@ -93,7 +93,7 @@ void NodeDialogCloud::load_thumbs_thread()
node->m_manager = m_manager; node->m_manager = m_manager;
node->init(); node->init();
node->m_text->set_text(n.c_str()); node->m_text->set_text(n.c_str());
node->m_path = App::I.work_path + "/" + n; node->m_path = App::I->work_path + "/" + n;
node->m_file_name = n; node->m_file_name = n;
container->add_child(node); container->add_child(node);
node->on_selected = [&](NodeDialogCloudItem* target) { node->on_selected = [&](NodeDialogCloudItem* target) {

20
src/node_dialog_open.cpp
View File

@@ -69,14 +69,14 @@ void NodeDialogOpen::init_controls()
root()->update(); root()->update();
}; };
container = find<Node>("files-list"); container = find<Node>("files-list");
auto names = Asset::list_files(App::I.work_path, ".*\\.ppi"); auto names = Asset::list_files(App::I->work_path, ".*\\.ppi");
for (const auto& n : names) for (const auto& n : names)
{ {
auto node = new NodeDialogOpenItem; auto node = new NodeDialogOpenItem;
node->m_manager = m_manager; node->m_manager = m_manager;
node->init(); node->init();
node->m_text->set_text(n.c_str()); node->m_text->set_text(n.c_str());
node->m_path = App::I.work_path + "/" + n; node->m_path = App::I->work_path + "/" + n;
node->m_file_name = n; node->m_file_name = n;
node->on_selected = [&](NodeDialogOpenItem* target) { node->on_selected = [&](NodeDialogOpenItem* target) {
if (target == current) if (target == current)
@@ -198,9 +198,9 @@ void NodeDialogSave::init_controls()
static char path_buffer[256]; static char path_buffer[256];
btn_path = find<NodeButton>("btn-path"); btn_path = find<NodeButton>("btn-path");
btn_path->on_click = [this](Node*){ btn_path->on_click = [this](Node*){
App::I.pick_dir([this](std::string path){ App::I->pick_dir([this](std::string path){
LOG("change working path to %s", path.c_str()); LOG("change working path to %s", path.c_str());
App::I.work_path = path; App::I->work_path = path;
#ifdef _WIN32 #ifdef _WIN32
GetFullPathNameA(path.c_str(), sizeof(path_buffer), path_buffer, nullptr); GetFullPathNameA(path.c_str(), sizeof(path_buffer), path_buffer, nullptr);
#else #else
@@ -211,9 +211,9 @@ void NodeDialogSave::init_controls()
}; };
working_path = find<NodeText>("path"); working_path = find<NodeText>("path");
#ifdef _WIN32 #ifdef _WIN32
GetFullPathNameA(App::I.work_path.c_str(), sizeof(path_buffer), path_buffer, nullptr); GetFullPathNameA(App::I->work_path.c_str(), sizeof(path_buffer), path_buffer, nullptr);
#else #else
realpath(App::I.work_path.c_str(), path_buffer); realpath(App::I->work_path.c_str(), path_buffer);
#endif #endif
working_path->set_text_format("Working dir: %s", path_buffer); working_path->set_text_format("Working dir: %s", path_buffer);
#endif #endif
@@ -259,9 +259,9 @@ void NodeDialogNewDoc::init_controls()
static char path_buffer[256]; static char path_buffer[256];
btn_path = find<NodeButton>("btn-path"); btn_path = find<NodeButton>("btn-path");
btn_path->on_click = [this](Node*){ btn_path->on_click = [this](Node*){
App::I.pick_dir([this](std::string path){ App::I->pick_dir([this](std::string path){
LOG("change working path to %s", path.c_str()); LOG("change working path to %s", path.c_str());
App::I.work_path = path; App::I->work_path = path;
#ifdef _WIN32 #ifdef _WIN32
GetFullPathNameA(path.c_str(), sizeof(path_buffer), path_buffer, nullptr); GetFullPathNameA(path.c_str(), sizeof(path_buffer), path_buffer, nullptr);
#else #else
@@ -272,9 +272,9 @@ void NodeDialogNewDoc::init_controls()
}; };
working_path = find<NodeText>("path"); working_path = find<NodeText>("path");
#ifdef _WIN32 #ifdef _WIN32
GetFullPathNameA(App::I.work_path.c_str(), sizeof(path_buffer), path_buffer, nullptr); GetFullPathNameA(App::I->work_path.c_str(), sizeof(path_buffer), path_buffer, nullptr);
#else #else
realpath(App::I.work_path.c_str(), path_buffer); realpath(App::I->work_path.c_str(), path_buffer);
#endif #endif
working_path->set_text_format("Working dir: %s", path_buffer); working_path->set_text_format("Working dir: %s", path_buffer);
#endif #endif

4
src/node_dialog_picker.cpp
View File

@@ -92,7 +92,7 @@ void NodeColorPicker::init_controls()
m_btn_paste->on_click = [this](Node*) m_btn_paste->on_click = [this](Node*)
{ {
std::string s = App::I.clipboard_get_text(); std::string s = App::I->clipboard_get_text();
std::regex r("#([\\dabcdefABCDEF]{6})"); std::regex r("#([\\dabcdefABCDEF]{6})");
std::smatch m; std::smatch m;
if (std::regex_search(s, m, r)) if (std::regex_search(s, m, r))
@@ -108,7 +108,7 @@ void NodeColorPicker::init_controls()
m_btn_copy->on_click = [this](Node*) m_btn_copy->on_click = [this](Node*)
{ {
App::I.clipboard_set_text(m_txt_hex->m_text); App::I->clipboard_set_text(m_txt_hex->m_text);
}; };
m_wheel->on_value_changed = [this](Node*, glm::vec3 hsv) m_wheel->on_value_changed = [this](Node*, glm::vec3 hsv)

4
src/node_dialog_resize.cpp
View File

@@ -34,7 +34,7 @@ void NodeDialogResize::init_controls()
text = find<NodeText>("current-res"); text = find<NodeText>("current-res");
resolution = Canvas::I->m_width; resolution = Canvas::I->m_width;
static char txt[128]; static char txt[128];
sprintf(txt, "Current: %s", App::I.res_to_string(resolution).c_str()); sprintf(txt, "Current: %s", App::I->res_to_string(resolution).c_str());
text->set_text(txt); text->set_text(txt);
btn_cancel->on_click = [this](Node*) { btn_cancel->on_click = [this](Node*) {
destroy(); destroy();
@@ -50,5 +50,5 @@ void NodeDialogResize::loaded()
int NodeDialogResize::get_resolution() int NodeDialogResize::get_resolution()
{ {
return combo ? App::I.res_from_index(combo->m_current_index) : 512; return combo ? App::I->res_from_index(combo->m_current_index) : 512;
} }

40
src/node_panel_brush.cpp
View File

@@ -48,8 +48,8 @@ bool NodeButtonBrush::read(BinaryStreamReader& r)
d.value<Serializer::CString>("high_path", high_path); d.value<Serializer::CString>("high_path", high_path);
d.value<Serializer::CString>("thumb_path", thumb_path); d.value<Serializer::CString>("thumb_path", thumb_path);
d.value<Serializer::Boolean>("m_user_brush", m_user_brush); d.value<Serializer::Boolean>("m_user_brush", m_user_brush);
high_path = str_replace(high_path, "{data_path}", App::I.data_path); high_path = str_replace(high_path, "{data_path}", App::I->data_path);
thumb_path = str_replace(thumb_path, "{data_path}", App::I.data_path); thumb_path = str_replace(thumb_path, "{data_path}", App::I->data_path);
return true; return true;
} }
@@ -60,9 +60,9 @@ void NodeButtonBrush::write(BinaryStreamWriter& w) const
d.name = L"Brush class"; d.name = L"Brush class";
d.props["brush_name"] = std::make_shared<Serializer::CString>(brush_name); d.props["brush_name"] = std::make_shared<Serializer::CString>(brush_name);
d.props["high_path"] = std::make_shared<Serializer::CString>( d.props["high_path"] = std::make_shared<Serializer::CString>(
str_replace(high_path, App::I.data_path, "{data_path}")); str_replace(high_path, App::I->data_path, "{data_path}"));
d.props["thumb_path"] = std::make_shared<Serializer::CString>( d.props["thumb_path"] = std::make_shared<Serializer::CString>(
str_replace(thumb_path, App::I.data_path, "{data_path}")); str_replace(thumb_path, App::I->data_path, "{data_path}"));
d.props["m_user_brush"] = std::make_shared<Serializer::Boolean>(m_user_brush); d.props["m_user_brush"] = std::make_shared<Serializer::Boolean>(m_user_brush);
w << d; w << d;
} }
@@ -78,7 +78,7 @@ void NodePanelBrush::init()
m_btn_add = find<NodeButtonCustom>("btn-add"); m_btn_add = find<NodeButtonCustom>("btn-add");
m_btn_add->on_click = [this](Node*) { m_btn_add->on_click = [this](Node*) {
App::I.pick_file({ "JPG", "PNG" }, [this](std::string path) { App::I->pick_file({ "JPG", "PNG" }, [this](std::string path) {
std::string name, base, ext; std::string name, base, ext;
std::regex r(R"((.*)[\\/]([^\\/]+)\.(\w+)$)"); std::regex r(R"((.*)[\\/]([^\\/]+)\.(\w+)$)");
std::smatch m; std::smatch m;
@@ -90,8 +90,8 @@ void NodePanelBrush::init()
Image img; Image img;
if (!m_dir_name.empty() && img.load_file(path)) if (!m_dir_name.empty() && img.load_file(path))
{ {
std::string path_high = App::I.data_path + "/" + m_dir_name + "/" + name + ".png"; std::string path_high = App::I->data_path + "/" + m_dir_name + "/" + name + ".png";
std::string path_thumb = App::I.data_path + "/" + m_dir_name + "/thumbs/" + name + ".png"; std::string path_thumb = App::I->data_path + "/" + m_dir_name + "/thumbs/" + name + ".png";
//img = img.resize_squared(glm::u8vec4(255)); //img = img.resize_squared(glm::u8vec4(255));
if (m_dir_name == "brushes") if (m_dir_name == "brushes")
@@ -170,11 +170,11 @@ void NodePanelBrush::init()
m_container = find<NodeScroll>("brushes"); m_container = find<NodeScroll>("brushes");
if (Asset::exist(App::I.data_path + "/settings/" + m_dir_name + ".bin") && !restore()) if (Asset::exist(App::I->data_path + "/settings/" + m_dir_name + ".bin") && !restore())
{ {
auto mb = App::I.message_box("Brushes", "Could not read brush textures file, it will be deleted.", true); auto mb = App::I->message_box("Brushes", "Could not read brush textures file, it will be deleted.", true);
mb->btn_ok->on_click = [this, mb](Node*) { mb->btn_ok->on_click = [this, mb](Node*) {
Asset::delete_file(App::I.data_path + "/settings/" + m_dir_name + ".bin"); Asset::delete_file(App::I->data_path + "/settings/" + m_dir_name + ".bin");
mb->destroy(); mb->destroy();
}; };
mb->btn_cancel->on_click = [mb](Node*) { mb->btn_cancel->on_click = [mb](Node*) {
@@ -202,11 +202,11 @@ void NodePanelBrush::init()
brush->on_click = std::bind(&NodePanelBrush::handle_click, this, std::placeholders::_1); brush->on_click = std::bind(&NodePanelBrush::handle_click, this, std::placeholders::_1);
} }
auto custom_icons = Asset::list_files(App::I.data_path + "/" + m_dir_name, ".*\\.png$"); auto custom_icons = Asset::list_files(App::I->data_path + "/" + m_dir_name, ".*\\.png$");
for (auto& i : custom_icons) for (auto& i : custom_icons)
{ {
std::string path_thumb = App::I.data_path + "/" + m_dir_name + "/thumbs/" + i; std::string path_thumb = App::I->data_path + "/" + m_dir_name + "/thumbs/" + i;
std::string path_high = App::I.data_path + "/" + m_dir_name + "/" + i; std::string path_high = App::I->data_path + "/" + m_dir_name + "/" + i;
NodeButtonBrush* brush = new NodeButtonBrush; NodeButtonBrush* brush = new NodeButtonBrush;
m_container->add_child(brush); m_container->add_child(brush);
brush->init(); brush->init();
@@ -287,7 +287,7 @@ std::string NodePanelBrush::get_thumb_path(int index) const
bool NodePanelBrush::save() bool NodePanelBrush::save()
{ {
std::ofstream f(App::I.data_path + "/settings/" + m_dir_name + ".bin", std::ios::binary); std::ofstream f(App::I->data_path + "/settings/" + m_dir_name + ".bin", std::ios::binary);
if (f.good()) if (f.good())
{ {
BinaryStreamWriter sw; BinaryStreamWriter sw;
@@ -310,7 +310,7 @@ bool NodePanelBrush::save()
bool NodePanelBrush::restore() bool NodePanelBrush::restore()
{ {
Asset f; Asset f;
auto path = App::I.data_path + "/settings/" + m_dir_name + ".bin"; auto path = App::I->data_path + "/settings/" + m_dir_name + ".bin";
if (f.open(path.c_str())) if (f.open(path.c_str()))
{ {
f.read_all(); f.read_all();
@@ -457,11 +457,11 @@ void NodePanelBrushPreset::init()
save(); save();
}; };
if (Asset::exist(App::I.data_path + "/settings/presets.bin") && !restore()) if (Asset::exist(App::I->data_path + "/settings/presets.bin") && !restore())
{ {
auto mb = App::I.message_box("Presets", "Could not read brush presets file, it will be deleted.", true); auto mb = App::I->message_box("Presets", "Could not read brush presets file, it will be deleted.", true);
mb->btn_ok->on_click = [mb](Node*) { mb->btn_ok->on_click = [mb](Node*) {
Asset::delete_file(App::I.data_path + "/settings/presets.bin"); Asset::delete_file(App::I->data_path + "/settings/presets.bin");
mb->destroy(); mb->destroy();
}; };
mb->btn_cancel->on_click = [mb](Node*) { mb->btn_cancel->on_click = [mb](Node*) {
@@ -509,7 +509,7 @@ void NodePanelBrushPreset::handle_click(Node* target)
bool NodePanelBrushPreset::save() bool NodePanelBrushPreset::save()
{ {
std::ofstream f(App::I.data_path + "/settings/presets.bin", std::ios::binary); std::ofstream f(App::I->data_path + "/settings/presets.bin", std::ios::binary);
if (f.good()) if (f.good())
{ {
BinaryStreamWriter sw; BinaryStreamWriter sw;
@@ -532,7 +532,7 @@ bool NodePanelBrushPreset::save()
bool NodePanelBrushPreset::restore() bool NodePanelBrushPreset::restore()
{ {
Asset f; Asset f;
auto path = App::I.data_path + "/settings/presets.bin"; auto path = App::I->data_path + "/settings/presets.bin";
if (f.open(path.c_str())) if (f.open(path.c_str()))
{ {
f.read_all(); f.read_all();

6
src/node_panel_grid.cpp
View File

@@ -76,7 +76,7 @@ void NodePanelGrid::init_controls()
}; };
m_hm_load->on_click = [this](Node*) { m_hm_load->on_click = [this](Node*) {
App::I.pick_image([this](std::string path) { App::I->pick_image([this](std::string path) {
Image img; Image img;
if (img.load_file(path)) if (img.load_file(path))
{ {
@@ -150,7 +150,7 @@ void NodePanelGrid::init_controls()
// get the texture data and resize it // get the texture data and resize it
Image img; Image img;
img.create(m_texture.size().x, m_texture.size().y); img.create(m_texture.size().x, m_texture.size().y);
App::I.render_task([&] App::I->render_task([&]
{ {
m_texture.bind(); m_texture.bind();
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img.m_data.get()); glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img.m_data.get());
@@ -465,7 +465,7 @@ void NodePanelGrid::bake_uvs()
//stbi_write_jpg("bake-out.jpg", fb.getWidth(), fb.getHeight(), 4, data_out.get(), 75); //stbi_write_jpg("bake-out.jpg", fb.getWidth(), fb.getHeight(), 4, data_out.get(), 75);
m_texture.update(data_out.get()); m_texture.update(data_out.get());
m_texture.create_mipmaps(); m_texture.create_mipmaps();
App::I.async_redraw(); App::I->async_redraw();
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

12
src/node_panel_quick.cpp
View File

@@ -119,8 +119,8 @@ void NodePanelQuick::init_controls()
m_slider_size = find<NodeSliderV>("quick-size"); m_slider_size = find<NodeSliderV>("quick-size");
m_slider_size->on_value_changed = [this](Node* target, float value) { m_slider_size->on_value_changed = [this](Node* target, float value) {
float off = App::I.ui_rtl ? -100.f : 100.f; float off = App::I->ui_rtl ? -100.f : 100.f;
auto newpos = (m_slider_flow->m_pos + glm::vec2(off, m_slider_flow->m_size.y / 2.f)) * App::I.zoom; auto newpos = (m_slider_flow->m_pos + glm::vec2(off, m_slider_flow->m_size.y / 2.f)) * App::I->zoom;
if (auto m = dynamic_cast<CanvasModePen*>(Canvas::I->modes[(int)Canvas::I->m_current_mode][0])) if (auto m = dynamic_cast<CanvasModePen*>(Canvas::I->modes[(int)Canvas::I->m_current_mode][0]))
{ {
m->m_cur_pos = newpos; m->m_cur_pos = newpos;
@@ -138,8 +138,8 @@ void NodePanelQuick::init_controls()
}; };
m_slider_flow = find<NodeSliderV>("quick-flow"); m_slider_flow = find<NodeSliderV>("quick-flow");
m_slider_flow->on_value_changed = [this](Node* target, float value) { m_slider_flow->on_value_changed = [this](Node* target, float value) {
float off = App::I.ui_rtl ? -100.f : 100.f; float off = App::I->ui_rtl ? -100.f : 100.f;
auto newpos = (m_slider_flow->m_pos + glm::vec2(off, m_slider_flow->m_size.y / 2.f)) * App::I.zoom; auto newpos = (m_slider_flow->m_pos + glm::vec2(off, m_slider_flow->m_size.y / 2.f)) * App::I->zoom;
if (auto m = dynamic_cast<CanvasModePen*>(Canvas::I->modes[(int)Canvas::I->m_current_mode][0])) if (auto m = dynamic_cast<CanvasModePen*>(Canvas::I->modes[(int)Canvas::I->m_current_mode][0]))
{ {
m->m_cur_pos = newpos; m->m_cur_pos = newpos;
@@ -205,7 +205,7 @@ void NodePanelQuick::handle_button_brush_click(Node* button)
// if the box is already selected show the popup // if the box is already selected show the popup
auto popup = App::I.presets; auto popup = App::I->presets;
auto screen = root()->m_size; auto screen = root()->m_size;
glm::vec2 tick_sz = { 16, 32 }; glm::vec2 tick_sz = { 16, 32 };
glm::vec2 tick_pos = button->m_pos + glm::vec2(button->m_size.x, 0); glm::vec2 tick_pos = button->m_pos + glm::vec2(button->m_size.x, 0);
@@ -287,7 +287,7 @@ void NodePanelQuick::handle_button_color_click(Node* target)
tick->set_image("data/ui/popup-tick.png"); tick->set_image("data/ui/popup-tick.png");
tick->m_scale = { 1, 1 }; tick->m_scale = { 1, 1 };
//float hh = popup->m_container->m_children.size() > 10 ? (screen.y / App::I.zoom - 90.f) : 400.f; //float hh = popup->m_container->m_children.size() > 10 ? (screen.y / App::I->zoom - 90.f) : 400.f;
//popup->SetHeight(glm::max(hh, 400.f)); //popup->SetHeight(glm::max(hh, 400.f));
popup->SetPositioning(YGPositionTypeAbsolute); popup->SetPositioning(YGPositionTypeAbsolute);
popup->SetPosition(popup_pos); popup->SetPosition(popup_pos);

44
src/node_panel_stroke.cpp
View File

@@ -42,7 +42,7 @@ bool NodePanelStroke::import_abr(const std::string& path)
if (!str_iequals(ext, "abr") || !Asset::exist(path)) if (!str_iequals(ext, "abr") || !Asset::exist(path))
return false; return false;
auto pb = App::I.show_progress("Importing ABR"); auto pb = App::I->show_progress("Importing ABR");
abr.open(path); abr.open(path);
@@ -55,8 +55,8 @@ bool NodePanelStroke::import_abr(const std::string& path)
auto ii = abr.m_samples.begin(); auto ii = abr.m_samples.begin();
std::advance(ii, i); std::advance(ii, i);
const auto& samp = *ii; const auto& samp = *ii;
std::string path_high = App::I.data_path + "/brushes/" + samp.first + ".png"; std::string path_high = App::I->data_path + "/brushes/" + samp.first + ".png";
std::string path_thumb = App::I.data_path + "/brushes/thumbs/" + samp.first + ".png"; std::string path_thumb = App::I->data_path + "/brushes/thumbs/" + samp.first + ".png";
auto padded = samp.second->resize_squared(glm::u8vec4(255)); auto padded = samp.second->resize_squared(glm::u8vec4(255));
//auto high = padded.resize_power2(); //auto high = padded.resize_power2();
//high.save(path_high); //high.save(path_high);
@@ -87,8 +87,8 @@ bool NodePanelStroke::import_abr(const std::string& path)
auto ii = abr.m_patterns.begin(); auto ii = abr.m_patterns.begin();
std::advance(ii, i); std::advance(ii, i);
const auto& patt = *ii; const auto& patt = *ii;
std::string path_high = App::I.data_path + "/patterns/" + patt.first + ".png"; std::string path_high = App::I->data_path + "/patterns/" + patt.first + ".png";
std::string path_thumb = App::I.data_path + "/patterns/thumbs/" + patt.first + ".png"; std::string path_thumb = App::I->data_path + "/patterns/thumbs/" + patt.first + ".png";
patt.second->save(path_high); patt.second->save(path_high);
auto thumb = patt.second->resize(64, 64); auto thumb = patt.second->resize(64, 64);
thumb.save(path_thumb); thumb.save(path_thumb);
@@ -110,20 +110,20 @@ bool NodePanelStroke::import_abr(const std::string& path)
}); });
m_pattern_popup->save(); m_pattern_popup->save();
auto brushes = abr.compute_brushes(App::I.data_path); auto brushes = abr.compute_brushes(App::I->data_path);
for (const auto& pr : brushes) for (const auto& pr : brushes)
{ {
if (pr->valid()) if (pr->valid())
{ {
LOG("add preset %s", pr->m_name.c_str()); LOG("add preset %s", pr->m_name.c_str());
App::I.presets->add_brush(pr); App::I->presets->add_brush(pr);
} }
count++; count++;
float prog = (float)count / (float)tot; float prog = (float)count / (float)tot;
pb->m_progress->SetWidthP(prog * 100.f); pb->m_progress->SetWidthP(prog * 100.f);
} }
App::I.presets->save(); App::I->presets->save();
pb->destroy(); pb->destroy();
//save(); //save();
@@ -281,32 +281,32 @@ void NodePanelStroke::init_controls()
m_preset_button->on_click = [this](Node*) { m_preset_button->on_click = [this](Node*) {
auto screen = root()->m_size; auto screen = root()->m_size;
glm::vec2 pos = m_preset_button->m_pos + glm::vec2(m_preset_button->m_size.x, 0); glm::vec2 pos = m_preset_button->m_pos + glm::vec2(m_preset_button->m_size.x, 0);
root()->add_child(App::I.presets); root()->add_child(App::I->presets);
auto tick = root()->add_child<NodeImage>(); auto tick = root()->add_child<NodeImage>();
tick->SetPositioning(YGPositionTypeAbsolute); tick->SetPositioning(YGPositionTypeAbsolute);
tick->SetSize(16, 32); tick->SetSize(16, 32);
tick->SetPosition(pos.x, pos.y + (m_preset_button->m_size.y - 32) * 0.5f); tick->SetPosition(pos.x, pos.y + (m_preset_button->m_size.y - 32) * 0.5f);
tick->set_image("data/ui/popup-tick.png"); tick->set_image("data/ui/popup-tick.png");
float hh = App::I.presets->m_container->m_children.size() > 10 ? App::I.height / App::I.zoom * .75f : 400.f; float hh = App::I->presets->m_container->m_children.size() > 10 ? App::I->height / App::I->zoom * .75f : 400.f;
App::I.presets->SetHeight(glm::max(hh, 400.f)); App::I->presets->SetHeight(glm::max(hh, 400.f));
root()->update(); root()->update();
if ((pos.y + App::I.presets->m_size.y) > screen.y) if ((pos.y + App::I->presets->m_size.y) > screen.y)
pos.y = screen.y - App::I.presets->m_size.y; pos.y = screen.y - App::I->presets->m_size.y;
if (pos.y < 0) if (pos.y < 0)
pos.y = 0; pos.y = 0;
App::I.presets->SetPosition(pos.x + 16, pos.y); App::I->presets->SetPosition(pos.x + 16, pos.y);
App::I.presets->SetPositioning(YGPositionTypeAbsolute); App::I->presets->SetPositioning(YGPositionTypeAbsolute);
App::I.presets->m_mouse_ignore = false; App::I->presets->m_mouse_ignore = false;
App::I.presets->m_flood_events = true; App::I->presets->m_flood_events = true;
App::I.presets->m_capture_children = false; App::I->presets->m_capture_children = false;
App::I.presets->mouse_capture(); App::I->presets->mouse_capture();
root()->update(); root()->update();
App::I.presets->on_popup_close = [this, tick](Node*) { App::I->presets->on_popup_close = [this, tick](Node*) {
tick->destroy(); tick->destroy();
}; };
App::I.presets->on_brush_changed = [this](Node* target, std::shared_ptr<Brush>& b) { App::I->presets->on_brush_changed = [this](Node* target, std::shared_ptr<Brush>& b) {
// don't change some params // don't change some params
//b->m_tip_size = Canvas::I->m_current_brush->m_tip_size; //b->m_tip_size = Canvas::I->m_current_brush->m_tip_size;
auto old_color = Canvas::I->m_current_brush->m_tip_color; auto old_color = Canvas::I->m_current_brush->m_tip_color;
@@ -629,7 +629,7 @@ void NodePanelStroke::init_controls()
b->m_tip_opacity = 1.f; b->m_tip_opacity = 1.f;
Canvas::I->m_current_brush = b; Canvas::I->m_current_brush = b;
update_controls(); update_controls();
App::I.brush_update(); App::I->brush_update();
}; };
update_controls(); update_controls();

14
src/node_stroke_preview.cpp
View File

@@ -231,11 +231,11 @@ std::vector<NodeStrokePreview::StrokeFrame> NodeStrokePreview::stroke_draw_compu
glm::vec2 mixer_bb_max(0, 0); glm::vec2 mixer_bb_max(0, 0);
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
{ {
auto p = (xy(prev.pos) + App::I.zoom * s.scale * off_mix[j] * glm::orientate2(-s.angle)); auto p = (xy(prev.pos) + App::I->zoom * s.scale * off_mix[j] * glm::orientate2(-s.angle));
mixer_bb_min = glm::max({ 0, 0 }, glm::min(mixer_bb_min, p)); mixer_bb_min = glm::max({ 0, 0 }, glm::min(mixer_bb_min, p));
mixer_bb_max = glm::min(mixer_sz, glm::max(mixer_bb_max, p)); mixer_bb_max = glm::min(mixer_sz, glm::max(mixer_bb_max, p));
B[j].pos = glm::vec4(xy(s.pos) + App::I.zoom * s.scale * off[j] * glm::orientate2(-s.angle) - glm::vec2(0, 1), 1, 1); B[j].pos = glm::vec4(xy(s.pos) + App::I->zoom * s.scale * off[j] * glm::orientate2(-s.angle) - glm::vec2(0, 1), 1, 1);
B[j].uvs2 = p / mixer_sz; B[j].uvs2 = p / mixer_sz;
} }
@@ -314,13 +314,13 @@ void NodeStrokePreview::draw_stroke_immediate()
{ {
float min_pad = size.x * 0.05f; float min_pad = size.x * 0.05f;
float pad = (5.f + glm::max(glm::min(m_stroke.m_max_size, m_brush->m_tip_size) / 2.f, min_pad)) * App::I.zoom; float pad = (5.f + glm::max(glm::min(m_stroke.m_max_size, m_brush->m_tip_size) / 2.f, min_pad)) * App::I->zoom;
if (b->m_tip_size_pressure) if (b->m_tip_size_pressure)
pad = min_pad * App::I.zoom; pad = min_pad * App::I->zoom;
if (!glm::isnan(m_pad_override)) if (!glm::isnan(m_pad_override))
pad = m_pad_override; pad = m_pad_override;
float w = m_size.x * App::I.zoom; float w = m_size.x * App::I->zoom;
float h = m_size.y * App::I.zoom; float h = m_size.y * App::I->zoom;
std::vector<glm::vec2> kp = { std::vector<glm::vec2> kp = {
{ pad, h / 2.f }, { pad, h / 2.f },
{ w / 2.f, 0 }, { w / 2.f, 0 },
@@ -529,7 +529,7 @@ void NodeStrokePreview::draw_stroke()
bool to_unload = (node->m_brush->m_tip_texture == nullptr); bool to_unload = (node->m_brush->m_tip_texture == nullptr);
node->m_brush->preload(); node->m_brush->preload();
App::I.render_task([node, to_unload] App::I->render_task([node, to_unload]
{ {
gl_state gl; gl_state gl;
gl.save(); gl.save();

2
src/node_text_input.cpp
View File

@@ -63,7 +63,7 @@ kEventResult NodeTextInput::handle_event(Event* e)
switch (e->m_type) switch (e->m_type)
{ {
case kEventType::MouseDownL: case kEventType::MouseDownL:
App::I.showKeyboard(); App::I->showKeyboard();
break; break;
case kEventType::MouseUpL: case kEventType::MouseUpL:
key_capture(); key_capture();

2
src/node_viewport.cpp
View File

@@ -18,7 +18,7 @@ void NodeViewport::draw()
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
auto box = m_clip * root()->m_zoom; auto box = m_clip * root()->m_zoom;
glm::ivec4 c = (glm::ivec4)glm::vec4(box.x, (int)(vp[3] - box.y - box.w), box.z, box.w); glm::ivec4 c = (glm::ivec4)glm::vec4(box.x, (int)(vp[3] - box.y - box.w), box.z, box.w);
glViewport(c.x + App::I.off_x, c.y + App::I.off_y, c.z, c.w); glViewport(c.x + App::I->off_x, c.y + App::I->off_y, c.z, c.w);
TextureManager::get(m_tex_id).bind(); TextureManager::get(m_tex_id).bind();
m_sampler->bind(0); m_sampler->bind(0);
glEnable(GL_BLEND); glEnable(GL_BLEND);

12
src/rtt.cpp
View File

@@ -39,7 +39,7 @@ void RTT::resize(int width, int height)
{ {
RTT new_rtt; RTT new_rtt;
App::I.render_task([&] App::I->render_task([&]
{ {
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &oldDFboID); glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &oldDFboID);
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &oldRFboID); glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &oldRFboID);
@@ -68,7 +68,7 @@ void RTT::resize(int width, int height)
void RTT::destroy() void RTT::destroy()
{ {
App::I.render_task_async([rboID=rboID, texID=texID, fboID=fboID] App::I->render_task_async([rboID=rboID, texID=texID, fboID=fboID]
{ {
if (rboID) if (rboID)
{ {
@@ -96,7 +96,7 @@ void RTT::destroy()
void RTT::copy(const RTT & source) void RTT::copy(const RTT & source)
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &oldDFboID); glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &oldDFboID);
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &oldRFboID); glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &oldRFboID);
@@ -113,7 +113,7 @@ void RTT::copy(const RTT & source)
bool RTT::create(int width, int height, int tex/* = -1*/, GLint internal_format, bool depth_buffer /*= false*/) bool RTT::create(int width, int height, int tex/* = -1*/, GLint internal_format, bool depth_buffer /*= false*/)
{ {
GLenum status = 0; GLenum status = 0;
App::I.render_task([&] App::I->render_task([&]
{ {
// Destroy any previously created object // Destroy any previously created object
destroy(); destroy();
@@ -254,7 +254,7 @@ uint8_t* RTT::readTextureData(uint8_t* buffer)
{ {
if (!buffer) if (!buffer)
buffer = createBuffer(); buffer = createBuffer();
App::I.render_task([&] App::I->render_task([&]
{ {
GLint old; GLint old;
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &old); glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &old);
@@ -269,7 +269,7 @@ float* RTT::readTextureDataFloat(float* buffer)
{ {
if (!buffer) if (!buffer)
buffer = createBufferFloat(); buffer = createBufferFloat();
App::I.render_task([&] App::I->render_task([&]
{ {
GLint old; GLint old;
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &old); glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &old);

4
src/settings.cpp
View File

@@ -6,7 +6,7 @@ Settings Settings::I;
bool Settings::load() bool Settings::load()
{ {
auto path = App::I.data_path + "/settings/pref.bin"; auto path = App::I->data_path + "/settings/pref.bin";
BinaryStreamReader sr; BinaryStreamReader sr;
if (sr.load(path)) if (sr.load(path))
{ {
@@ -18,7 +18,7 @@ bool Settings::load()
bool Settings::save() bool Settings::save()
{ {
auto path = App::I.data_path + "/settings/pref.bin"; auto path = App::I->data_path + "/settings/pref.bin";
BinaryStreamWriter sw; BinaryStreamWriter sw;
sw.init(); sw.init();
I.write(sw); I.write(sw);

4
src/shader.cpp
View File

@@ -155,7 +155,7 @@ bool Shader::reload()
bool Shader::create(const char* vertex, const char* fragment) bool Shader::create(const char* vertex, const char* fragment)
{ {
bool ret = true; bool ret = true;
App::I.render_task([&] App::I->render_task([&]
{ {
GLint status; GLint status;
static char infolog[4096]; static char infolog[4096];
@@ -278,7 +278,7 @@ void Shader::destroy()
{ {
if (prog) if (prog)
{ {
App::I.render_task_async([prog=prog] App::I->render_task_async([prog=prog]
{ {
glUseProgram(0); glUseProgram(0);
glDeleteProgram(prog); glDeleteProgram(prog);

16
src/shape.cpp
View File

@@ -22,7 +22,7 @@ bool Shape::create_buffers_imp(GLvoid* idx, GLvoid* vertices, int isize, int vsi
use_idx = true; use_idx = true;
bool ret = false; bool ret = false;
App::I.render_task([&] App::I->render_task([&]
{ {
destroy(); destroy();
@@ -71,7 +71,7 @@ bool Shape::create_buffers(GLvoid* vertices, int vsize)
use_idx = false; use_idx = false;
bool ret = false; bool ret = false;
App::I.render_task([&] App::I->render_task([&]
{ {
destroy(); destroy();
@@ -124,7 +124,7 @@ void Shape::draw_fill() const
type = GL_POINTS; type = GL_POINTS;
if (count[0] == 2) if (count[0] == 2)
type = GL_LINES; type = GL_LINES;
App::I.render_task([=] App::I->render_task([=]
{ {
#if USE_VBO #if USE_VBO
glBindVertexArray(arrays[0]); glBindVertexArray(arrays[0]);
@@ -160,7 +160,7 @@ void Shape::draw_stroke() const
GLenum type = GL_LINES; GLenum type = GL_LINES;
if (count[1] == 1) if (count[1] == 1)
type = GL_POINTS; type = GL_POINTS;
App::I.render_task([=] App::I->render_task([=]
{ {
#if USE_VBO #if USE_VBO
glBindVertexArray(arrays[1]); glBindVertexArray(arrays[1]);
@@ -193,7 +193,7 @@ void Shape::draw_stroke() const
void Shape::destroy() void Shape::destroy()
{ {
App::I.render_task_async([b1=buffers[0],b2=buffers[1],a1=arrays[0],a2=arrays[1]] App::I->render_task_async([b1=buffers[0],b2=buffers[1],a1=arrays[0],a2=arrays[1]]
{ {
if (b1 || b2) if (b1 || b2)
{ {
@@ -490,7 +490,7 @@ void Plane::update_vertices(const glm::vec4* data, const glm::vec2* uvs, const g
vertices[i].pos.z = q; vertices[i].pos.z = q;
} }
App::I.render_task([this] App::I->render_task([this]
{ {
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]); glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
@@ -760,7 +760,7 @@ void Sphere::create_impl(int rings, int sectors, float radius,
} }
void LineSegment::update_vertices(const glm::vec4 data[2]) void LineSegment::update_vertices(const glm::vec4 data[2])
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
static vertex_t vertices[2]; static vertex_t vertices[2];
vertices[0] = { data[0], { 0, 0 } }; // A vertices[0] = { data[0], { 0, 0 } }; // A
@@ -772,7 +772,7 @@ void LineSegment::update_vertices(const glm::vec4 data[2])
} }
void DynamicShape::update_vertices(vertex_t* vertices, int vcount) void DynamicShape::update_vertices(vertex_t* vertices, int vcount)
{ {
App::I.render_task([&] App::I->render_task([&]
{ {
count[0] = vcount; count[0] = vcount;
count[1] = vcount; count[1] = vcount;

20
src/texture.cpp
View File

@@ -41,7 +41,7 @@ void TextureManager::invalidate()
bool Texture2D::create(int width, int height, GLint internal_format, GLint format, const uint8_t* data) bool Texture2D::create(int width, int height, GLint internal_format, GLint format, const uint8_t* data)
{ {
App::I.render_task([=] App::I->render_task([=]
{ {
destroy(); destroy();
m_width = width; m_width = width;
@@ -68,7 +68,7 @@ bool Texture2D::create(const Image& img)
void Texture2D::create_mipmaps() void Texture2D::create_mipmaps()
{ {
App::I.render_task([this] App::I->render_task([this]
{ {
bind(); bind();
glGenerateMipmap(GL_TEXTURE_2D); glGenerateMipmap(GL_TEXTURE_2D);
@@ -108,7 +108,7 @@ void Texture2D::destroy()
{ {
if (m_tex) if (m_tex)
{ {
App::I.render_task_async([id = m_tex] App::I->render_task_async([id = m_tex]
{ {
glDeleteTextures(1, &id); glDeleteTextures(1, &id);
}); });
@@ -128,7 +128,7 @@ void Texture2D::unbind() const
void Texture2D::update(const uint8_t* data) void Texture2D::update(const uint8_t* data)
{ {
App::I.render_task([this, data] App::I->render_task([this, data]
{ {
bind(); bind();
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_width, m_height, m_format, GL_UNSIGNED_BYTE, data); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_width, m_height, m_format, GL_UNSIGNED_BYTE, data);
@@ -152,7 +152,7 @@ Texture2D::~Texture2D()
bool Sampler::create(GLint filter /*= GL_LINEAR*/, GLint wrap /*= GL_CLAMP_TO_EDGE*/) bool Sampler::create(GLint filter /*= GL_LINEAR*/, GLint wrap /*= GL_CLAMP_TO_EDGE*/)
{ {
bool ret = false; bool ret = false;
App::I.render_task([this, &ret, filter, wrap] App::I->render_task([this, &ret, filter, wrap]
{ {
#if USE_SAMPLER #if USE_SAMPLER
glGenSamplers(1, &id); glGenSamplers(1, &id);
@@ -169,7 +169,7 @@ bool Sampler::create(GLint filter /*= GL_LINEAR*/, GLint wrap /*= GL_CLAMP_TO_ED
} }
void Sampler::set(GLint filter /*= GL_LINEAR*/, GLint wrap /*= GL_CLAMP_TO_EDGE*/) void Sampler::set(GLint filter /*= GL_LINEAR*/, GLint wrap /*= GL_CLAMP_TO_EDGE*/)
{ {
App::I.render_task([=] App::I->render_task([=]
{ {
#if USE_SAMPLER #if USE_SAMPLER
glSamplerParameteri(id, GL_TEXTURE_WRAP_S, wrap); glSamplerParameteri(id, GL_TEXTURE_WRAP_S, wrap);
@@ -182,7 +182,7 @@ void Sampler::set(GLint filter /*= GL_LINEAR*/, GLint wrap /*= GL_CLAMP_TO_EDGE*
} }
void Sampler::set_filter(GLint filter_min, GLint filter_mag) void Sampler::set_filter(GLint filter_min, GLint filter_mag)
{ {
App::I.render_task([=] App::I->render_task([=]
{ {
#if USE_SAMPLER #if USE_SAMPLER
glSamplerParameteri(id, GL_TEXTURE_MIN_FILTER, filter_min); glSamplerParameteri(id, GL_TEXTURE_MIN_FILTER, filter_min);
@@ -192,7 +192,7 @@ void Sampler::set_filter(GLint filter_min, GLint filter_mag)
} }
void Sampler::set_border(glm::vec4 rgba) void Sampler::set_border(glm::vec4 rgba)
{ {
App::I.render_task([this, rgba] App::I->render_task([this, rgba]
{ {
#if USE_SAMPLER && !defined(__IOS__) && !defined(__ANDROID__) #if USE_SAMPLER && !defined(__IOS__) && !defined(__ANDROID__)
glSamplerParameterfv(id, GL_TEXTURE_BORDER_COLOR, glm::value_ptr(rgba)); glSamplerParameterfv(id, GL_TEXTURE_BORDER_COLOR, glm::value_ptr(rgba));
@@ -201,7 +201,7 @@ void Sampler::set_border(glm::vec4 rgba)
} }
void Sampler::bind(int unit) const void Sampler::bind(int unit) const
{ {
App::I.render_task([=] App::I->render_task([=]
{ {
current_unit = unit; current_unit = unit;
#if USE_SAMPLER #if USE_SAMPLER
@@ -211,7 +211,7 @@ void Sampler::bind(int unit) const
} }
void Sampler::unbind() void Sampler::unbind()
{ {
App::I.render_task([=] App::I->render_task([=]
{ {
#if USE_SAMPLER #if USE_SAMPLER
glBindSampler(current_unit, 0); glBindSampler(current_unit, 0);