void Visualization_layer::activate() {
set_active(true);
}
void CL_GL1CreationHelper::set_multisampling_pixel_format(const CL_GL1WindowDescription &gldesc)
{
PIXELFORMATDESCRIPTOR pfd;
memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
pfd.iPixelType = PFD_TYPE_RGBA;
if (gldesc.get_doublebuffer()) pfd.dwFlags |= PFD_DOUBLEBUFFER;
if (gldesc.get_stereo()) pfd.dwFlags |= PFD_STEREO;
pfd.cColorBits = gldesc.get_buffer_size();
pfd.cRedBits = gldesc.get_red_size();
pfd.cGreenBits = gldesc.get_green_size();
pfd.cBlueBits = gldesc.get_blue_size();
pfd.cAlphaBits = gldesc.get_alpha_size();
pfd.cDepthBits = gldesc.get_depth_size();
pfd.cStencilBits = gldesc.get_stencil_size();
if (gldesc.is_layered())
{
pfd.cAlphaBits = 8;
pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE; // | PFD_DRAW_TO_BITMAP
}
if (gldesc.get_multisampling() < 1)
{
int pixelformat = ChoosePixelFormat(hdc, &pfd);
SetPixelFormat(hdc, pixelformat, &pfd);
}
else
{
int pixelformat = ChoosePixelFormat(hdc, &pfd);
set_active();
ptr_wglChoosePixelFormatEXT wglChoosePixelFormatEXT = (ptr_wglChoosePixelFormatEXT) wglGetProcAddress("wglChoosePixelFormatEXT");
if (wglChoosePixelFormatEXT == 0)
wglChoosePixelFormatEXT = (ptr_wglChoosePixelFormatEXT) wglGetProcAddress("wglChoosePixelFormatARB");
reset_active();
if (wglChoosePixelFormatEXT)
{
std::vector<FLOAT> float_attributes;
std::vector<int> int_attributes;
int_attributes.push_back(WGL_DRAW_TO_WINDOW);
int_attributes.push_back(GL_TRUE);
int_attributes.push_back(WGL_ACCELERATION);
int_attributes.push_back(WGL_FULL_ACCELERATION);
if (gldesc.get_doublebuffer())
{
int_attributes.push_back(WGL_DOUBLE_BUFFER);
int_attributes.push_back(GL_TRUE);
}
if (gldesc.get_stereo())
{
int_attributes.push_back(WGL_STEREO);
int_attributes.push_back(GL_TRUE);
}
int_attributes.push_back(WGL_COLOR_BITS);
int_attributes.push_back(gldesc.get_red_size() + gldesc.get_green_size() + gldesc.get_blue_size());
int_attributes.push_back(WGL_ALPHA_BITS);
int_attributes.push_back(gldesc.get_alpha_size());
int_attributes.push_back(WGL_DEPTH_BITS);
int_attributes.push_back(gldesc.get_depth_size());
int_attributes.push_back(WGL_STENCIL_BITS);
int_attributes.push_back(gldesc.get_stencil_size());
int_attributes.push_back(WGL_SAMPLE_BUFFERS);
int_attributes.push_back(GL_TRUE);
int_attributes.push_back(WGL_SAMPLES);
int_attributes.push_back(gldesc.get_multisampling());
float_attributes.push_back(0.0f);
float_attributes.push_back(0.0f);
int_attributes.push_back(0);
int_attributes.push_back(0);
int new_pixelformat = pixelformat;
UINT num_formats = 0;
BOOL result = wglChoosePixelFormatEXT(hdc, &int_attributes[0], &float_attributes[0], 1, &new_pixelformat, &num_formats);
if (result == TRUE && num_formats > 0)
pixelformat = new_pixelformat;
}
SetPixelFormat(hdc, pixelformat, &pfd);
}
}
void Body2DSW::set_state(Physics2DServer::BodyState p_state, const Variant& p_variant) {
switch(p_state) {
case Physics2DServer::BODY_STATE_TRANSFORM: {
if (mode==Physics2DServer::BODY_MODE_KINEMATIC) {
new_transform=p_variant;
//wakeup_neighbours();
set_active(true);
if (first_time_kinematic) {
_set_transform(p_variant);
_set_inv_transform(get_transform().affine_inverse());
first_time_kinematic=false;
}
} else if (mode==Physics2DServer::BODY_MODE_STATIC) {
_set_transform(p_variant);
_set_inv_transform(get_transform().affine_inverse());
wakeup_neighbours();
} else {
Matrix32 t = p_variant;
t.orthonormalize();
new_transform=get_transform(); //used as old to compute motion
if (t==new_transform)
break;
_set_transform(t);
_set_inv_transform(get_transform().inverse());
}
wakeup();
} break;
case Physics2DServer::BODY_STATE_LINEAR_VELOCITY: {
//if (mode==Physics2DServer::BODY_MODE_STATIC)
// break;
linear_velocity=p_variant;
wakeup();
} break;
case Physics2DServer::BODY_STATE_ANGULAR_VELOCITY: {
//if (mode!=Physics2DServer::BODY_MODE_RIGID)
// break;
angular_velocity=p_variant;
wakeup();
} break;
case Physics2DServer::BODY_STATE_SLEEPING: {
//?
if (mode==Physics2DServer::BODY_MODE_STATIC || mode==Physics2DServer::BODY_MODE_KINEMATIC)
break;
bool do_sleep=p_variant;
if (do_sleep) {
linear_velocity=Vector2();
//biased_linear_velocity=Vector3();
angular_velocity=0;
//biased_angular_velocity=Vector3();
set_active(false);
} else {
if (mode!=Physics2DServer::BODY_MODE_STATIC)
set_active(true);
}
} break;
case Physics2DServer::BODY_STATE_CAN_SLEEP: {
can_sleep=p_variant;
if (mode==Physics2DServer::BODY_MODE_RIGID && !active && !can_sleep)
set_active(true);
} break;
}
}
void Data_Elise_Gra_Win::set_fill_style(Data_Fill_St * dfst)
{
set_active();
set_col(dfst->dcp());
}
void Renderer::draw_single_threaded(std::vector<SceneGraph const*> const& scene_graphs) {
for (auto graph : scene_graphs) {
graph->update_cache();
}
auto sgs = garbage_collected_copy(scene_graphs);
for (auto graph : scene_graphs) {
for (auto& cam : graph->get_camera_nodes()) {
auto window_name(cam->config.get_output_window_name());
auto serialized_cam(cam->serialize());
if (window_name != "") {
auto window = WindowDatabase::instance()->lookup(window_name);
if (window && !window->get_is_open()) {
window->open();
}
// update window if one is assigned
if (window && window->get_is_open()) {
window->set_active(true);
window->start_frame();
if (window->get_context()->framecount == 0) {
display_loading_screen(*window);
}
// make sure pipeline was created
std::shared_ptr<Pipeline> pipe = nullptr;
auto pipe_iter = window->get_context()->render_pipelines.find(
serialized_cam.uuid);
if (pipe_iter == window->get_context()->render_pipelines.end()) {
pipe = std::make_shared<Pipeline>(
*window->get_context(),
serialized_cam.config.get_resolution());
window->get_context()->render_pipelines.insert(
std::make_pair(serialized_cam.uuid, pipe));
} else {
pipe = pipe_iter->second;
}
window->rendering_fps = application_fps_.fps;
if (serialized_cam.config.get_enable_stereo()) {
if (window->config.get_stereo_mode() == StereoMode::NVIDIA_3D_VISION) {
#ifdef GUACAMOLE_ENABLE_NVIDIA_3D_VISION
if ((window->get_context()->framecount % 2) == 0) {
auto img(pipe->render_scene(CameraMode::LEFT, serialized_cam, *sgs));
if (img) window->display(img, true);
} else {
auto img(pipe->render_scene(CameraMode::RIGHT, serialized_cam, *sgs));
if (img) window->display(img, false);
}
#else
Logger::LOG_WARNING << "guacamole has not been compiled with NVIDIA 3D Vision support!" << std::endl;
#endif
} else {
auto img(pipe->render_scene(CameraMode::LEFT, serialized_cam, *sgs));
if (img) window->display(img, true);
img = pipe->render_scene(CameraMode::RIGHT, serialized_cam, *sgs);
if (img) window->display(img, false);
}
} else {
auto img(pipe->render_scene(serialized_cam.config.get_mono_mode(),
serialized_cam, *sgs));
if (img) window->display(img, serialized_cam.config.get_mono_mode() != CameraMode::RIGHT);
}
pipe->clear_frame_cache();
// swap buffers
window->finish_frame();
++(window->get_context()->framecount);
}
}
}
}
application_fps_.step();
}
Graph::flowtype Graph::maxflow()
{
node *i, *j, *current_node = NULL;
arc *a;
nodeptr *np, *np_next;
maxflow_init();
nodeptr_block = new DBlock<nodeptr>(NODEPTR_BLOCK_SIZE, error_function);
while (1)
{
if ((i = current_node))
{
i->next = NULL; /* remove active flag */
if (!i->parent) i = NULL;
}
if (!i)
{
if (!(i = next_active())) break;
}
/* growth */
if (!i->is_sink)
{
/* grow source tree */
for (a = i->first; a; a = a->next)
if (a->r_cap)
{
j = a->head;
if (!j->parent)
{
j->is_sink = 0;
j->parent = a->sister;
j->TS = i->TS;
j->DIST = i->DIST + 1;
set_active(j);
}
else if (j->is_sink) break;
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the source shorter */
j->parent = a->sister;
j->TS = i->TS;
j->DIST = i->DIST + 1;
}
}
}
else
{
/* grow sink tree */
for (a = i->first; a; a = a->next)
if (a->sister->r_cap)
{
j = a->head;
if (!j->parent)
{
j->is_sink = 1;
j->parent = a->sister;
j->TS = i->TS;
j->DIST = i->DIST + 1;
set_active(j);
}
else if (!j->is_sink) { a = a->sister; break; }
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the sink shorter */
j->parent = a->sister;
j->TS = i->TS;
j->DIST = i->DIST + 1;
}
}
}
TIME++;
if (a)
{
i->next = i; /* set active flag */
current_node = i;
/* augmentation */
augment(a);
/* augmentation end */
/* adoption */
while ((np = orphan_first))
{
np_next = np->next;
np->next = NULL;
while ((np = orphan_first))
{
orphan_first = np->next;
i = np->ptr;
nodeptr_block->Delete(np);
if (!orphan_first) orphan_last = NULL;
if (i->is_sink) process_sink_orphan(i);
else process_source_orphan(i);
}
orphan_first = np_next;
}
/* adoption end */
}
else current_node = NULL;
}
delete nodeptr_block;
return flow;
}
iface::~iface()
{
set_active(false);
glXDestroyContext(gui::g_display, context_);
}
void OptionMenu::enter(char untilExitFlag)
{
if( is_active() )
return;
int bx = (VGA_WIDTH - PAGE_WIDTH) / 2;
int by = (VGA_HEIGHT - PAGE_HEIGHT) / 2;
int i;
refresh_flag = IGOPTION_ALL;
update_flag = 0;
// active_flag = 1;
set_active();
info.save_game_scr();
Config& tempConfig = config;
old_config = config;
// -------- initialize sound effect volume --------//
// se_vol_slide.init_slide(264, 123, 420, 123+SLIDE_BUTTON_HEIGHT-1,
// SLIDE_BUTTON_WIDTH, disp_slide_bar);
se_vol_slide.init_slide(bx+140, by+118, bx+140+10*SLIDE_BUTTON_WIDTH+9*2, by+118+SLIDE_BUTTON_HEIGHT-1,
SLIDE_BUTTON_WIDTH, disp_slide_bar);
se_vol_slide.set(0, 100, tempConfig.sound_effect_flag ? tempConfig.sound_effect_volume : 0);
// -------- initialize music volume --------//
// music_vol_slide.init_slide(566, 123, 722, 123+SLIDE_BUTTON_HEIGHT-1,
// SLIDE_BUTTON_WIDTH, disp_slide_bar);
// music_vol_slide.init_slide(bx+140, by+173, bx+140+10*SLIDE_BUTTON_WIDTH+9*2, by+173+SLIDE_BUTTON_HEIGHT-1,
// SLIDE_BUTTON_WIDTH, disp_slide_bar);
// music_vol_slide.set(0, 100, tempConfig.music_flag ? tempConfig.wav_music_volume : 0);
int cx = bx + 124;
int cy = by + 173;
for( i = 0; i < 2; ++i )
{
int cx2 = cx + font_thin_black.text_width(text_game_menu.str_no_yes(i)) + 9;
music_group[i].create(cx, cy, cx2, cy + font_thin_black.max_font_height+3,
disp_text_button, ButtonCustomPara(text_game_menu.str_no_yes(i), i), 0, 0);
cx = cx2 + 5;
}
// -------- initialize frame speed volume --------//
// frame_speed_slide.init_slide(196, 410, 352, 410+SLIDE_BUTTON_HEIGHT-1,
// SLIDE_BUTTON_WIDTH, disp_slide_bar);
frame_speed_slide.init_slide(bx+140, by+338, bx+140+10*SLIDE_BUTTON_WIDTH+9*2, by+338+SLIDE_BUTTON_HEIGHT-1,
SLIDE_BUTTON_WIDTH, disp_slide_bar);
frame_speed_slide.set(0, 31, tempConfig.frame_speed <= 30 ? tempConfig.frame_speed: 31);
// use frame 31 to represent full speed (i.e. 99)
// -------- initialize scroll speed volume --------//
// scroll_speed_slide.init_slide(196, 454, 352, 454+SLIDE_BUTTON_HEIGHT-1,
// SLIDE_BUTTON_WIDTH, disp_slide_bar);
scroll_speed_slide.init_slide(bx+140, by+398, bx+140+10*SLIDE_BUTTON_WIDTH+9*2, by+398+SLIDE_BUTTON_HEIGHT-1,
SLIDE_BUTTON_WIDTH, disp_slide_bar);
scroll_speed_slide.set(0, 10, tempConfig.scroll_speed );
// --------- initialize race buttons ---------- //
// for( i = 0; i < MAX_RACE; ++i )
// {
// race_button[i].create(181+i*BASIC_OPTION_X_SPACE, 162,
// 181+(i+1)*BASIC_OPTION_X_SPACE-1, 162+BASIC_OPTION_HEIGHT-1,
// disp_virtual_button, ButtonCustomPara(NULL, race_table[i]));
// }
// --------- initialize help button group ---------- //
cx = bx + 124;
cy = by + 226;
for( i = 0; i < 3; ++i )
{
int cx2 = cx + font_thin_black.text_width(text_game_menu.str_help_options(i)) + 9;
help_group[i].create(cx, cy, cx2, cy + font_thin_black.max_font_height+3,
disp_text_button, ButtonCustomPara(text_game_menu.str_help_options(i), i), 0, 0);
cx = cx2 + 5;
}
// --------- initialize news button group ---------- //
cx = bx + 124;
cy = by + 281;
for( i = 0; i < 2; ++i )
{
int cx2 = cx + font_thin_black.text_width(text_game_menu.str_news_options(i)) + 9;
news_group[i].create(cx, cy, cx2, cy + font_thin_black.max_font_height+3,
disp_text_button, ButtonCustomPara(text_game_menu.str_news_options(i), i), 0, 0);
cx = cx2 + 5;
}
// --------- initialize report button group ---------- //
cx = bx + 417;
cy = by + 116;
for( i = 0; i < 2; ++i )
{
int cx2 = cx + font_thin_black.text_width( text_game_menu.str_report_options(i) ) + 9;
report_group[i].create( cx, cy, cx2, cy + font_thin_black.max_font_height+3,
disp_text_button, ButtonCustomPara(text_game_menu.str_report_options(i), i), 0, 0);
cx = cx2 + 5;
}
// --------- initialize show icon button group ---------- //
cx = bx + 417;
cy = by + 181;
for( i = 0; i < 2; ++i )
{
int cx2 = cx + font_thin_black.text_width( text_game_menu.str_show_icon_options(i) ) + 9;
show_icon_group[i].create( cx, cy, cx2, cy + font_thin_black.max_font_height+3,
disp_text_button, ButtonCustomPara(text_game_menu.str_show_icon_options(i), i), 0, 0);
cx = cx2 + 10;
}
// --------- initialize show path button group ---------- //
cx = bx + 417;
cy = by + 256;
for( i = 0; i < 4; ++i )
{
int cx2 = cx + font_thin_black.text_width(text_game_menu.str_show_path_options(i)) + 9;
show_path_group[i].create( cx, cy, cx2, cy + font_thin_black.max_font_height+3,
disp_text_button, ButtonCustomPara(text_game_menu.str_show_path_options(i), i), 0, 0);
if( i & 1 )
{
cx = bx+417;
cy += font_thin_black.max_font_height + 3;
}
else
{
// ####### begin Gilbert 7/6 ########//
cx = cx2 + 20;
// ####### end Gilbert 7/6 ########//
}
}
// --------- initialize inside info button group ----------//
cx = bx + 417;
cy = by + 331;
for( i = 0; i < 3; ++i )
{
int cx2 = cx + font_thin_black.text_width(text_game_menu.str_inside_info_options(i)) + 9;
inside_info_group[i].create( cx, cy, cx2, cy + font_thin_black.max_font_height+3,
disp_text_button, ButtonCustomPara( text_game_menu.str_inside_info_options(i), i), 0, 0);
cx = cx2 + 5;
}
// -------- initialize scroll method group -------//
cx = bx + 417;
cy = by + 391;
for( i = 0; i < 2; ++i )
{
int cx2 = cx + font_thin_black.text_width(text_game_menu.str_scroll_method_options(i)) + 9;
scroll_method_group[i].create( cx, cy, cx2, cy + font_thin_black.max_font_height+3,
disp_text_button, ButtonCustomPara(text_game_menu.str_scroll_method_options(i), i), 0, 0);
cx = cx2 + 5;
}
// --------- other buttons --------//
start_button.create_text( bx+BUTTON2_X1, by+BUTTON2_Y1, bx+BUTTON2_X2, by+BUTTON2_Y2, text_game_menu.str_return() );
cancel_button.create_text( bx+BUTTON4_X1, by+BUTTON4_Y1, bx+BUTTON4_X2, by+BUTTON4_Y2, text_game_menu.str_cancel() );
mouse_cursor.set_icon(CURSOR_NORMAL);
mouse_cursor.set_frame(0);
power.win_opened = 1;
if( untilExitFlag )
{
while( is_active() )
{
sys.yield();
mouse.get_event();
if( config.music_flag )
{
if( !music.is_playing() )
music.play( music.random_bgm_track(music.song_id), sys.cdrom_drive ? MUSIC_CD_THEN_WAV : 0 );
}
else
music.stop();
disp();
sys.blt_virtual_buf();
music.yield();
detect();
}
}
}
void QPBO<REAL>::maxflow_reuse_trees_init()
{
Node* i;
Node* j;
Node* queue = queue_first[1];
Arc* a;
nodeptr* np;
queue_first[0] = queue_last[0] = NULL;
queue_first[1] = queue_last[1] = NULL;
orphan_first = orphan_last = NULL;
TIME ++;
while ((i=queue))
{
queue = i->next;
if (queue == i) queue = NULL;
if (IsNode0(i))
{
if (i->is_removed) continue;
}
else
{
if (GetMate1(i)->is_removed) continue;
}
i->next = NULL;
i->is_marked = 0;
set_active(i);
if (i->tr_cap == 0)
{
if (i->parent) set_orphan_rear(i);
continue;
}
if (i->tr_cap > 0)
{
if (!i->parent || i->is_sink)
{
i->is_sink = 0;
for (a=i->first; a; a=a->next)
{
j = a->head;
if (!j->is_marked)
{
if (j->parent == a->sister) set_orphan_rear(j);
if (j->parent && j->is_sink && a->r_cap > 0) set_active(j);
}
}
add_to_changed_list(i);
}
}
else
{
if (!i->parent || !i->is_sink)
{
i->is_sink = 1;
for (a=i->first; a; a=a->next)
{
j = a->head;
if (!j->is_marked)
{
if (j->parent == a->sister) set_orphan_rear(j);
if (j->parent && !j->is_sink && a->sister->r_cap > 0) set_active(j);
}
}
add_to_changed_list(i);
}
}
i->parent = QPBO_MAXFLOW_TERMINAL;
i -> TS = TIME;
i -> DIST = 1;
}
code_assert(stage == 1);
//test_consistency();
/* adoption */
while ((np=orphan_first))
{
orphan_first = np -> next;
i = np -> ptr;
nodeptr_block -> Delete(np);
if (!orphan_first) orphan_last = NULL;
if (i->is_sink) process_sink_orphan(i);
else process_source_orphan(i);
}
/* adoption end */
//test_consistency();
}
Graph::flowtype Graph::maxflow()
{
node *i, *j, *current_node = NULL, *s_start, *t_start = NULL;
captype *cap_middle = NULL, *rev_cap_middle = NULL;
arc_forward *a_for, *a_for_first, *a_for_last;
arc_reverse *a_rev, *a_rev_first, *a_rev_last;
nodeptr *np, *np_next;
prepare_graph();
maxflow_init();
nodeptr_block = new DBlock<nodeptr>(NODEPTR_BLOCK_SIZE, error_function);
while ( 1 )
{
if ((i=current_node))
{
i -> next = NULL; /* remove active flag */
if (!i->parent) i = NULL;
}
if (!i)
{
if (!(i = next_active())) break;
}
/* growth */
s_start = NULL;
a_for_first = i -> first_out;
if (IS_ODD(a_for_first))
{
a_for_first = (arc_forward *) (((char *)a_for_first) + 1);
a_for_last = (arc_forward *) ((a_for_first ++) -> shift);
}
else a_for_last = (i + 1) -> first_out;
a_rev_first = i -> first_in;
if (IS_ODD(a_rev_first))
{
a_rev_first = (arc_reverse *) (((char *)a_rev_first) + 1);
a_rev_last = (arc_reverse *) ((a_rev_first ++) -> sister);
}
else a_rev_last = (i + 1) -> first_in;
if (!i->is_sink)
{
/* grow source tree */
for (a_for=a_for_first; a_for<a_for_last; a_for++)
if (a_for->r_cap)
{
j = NEIGHBOR_NODE(i, a_for -> shift);
if (!j->parent)
{
j -> is_sink = 0;
j -> parent = MAKE_ODD(a_for);
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
set_active(j);
}
else if (j->is_sink)
{
s_start = i;
t_start = j;
cap_middle = & ( a_for -> r_cap );
rev_cap_middle = & ( a_for -> r_rev_cap );
break;
}
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the source shorter */
j -> parent = MAKE_ODD(a_for);
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
}
}
if (!s_start)
for (a_rev=a_rev_first; a_rev<a_rev_last; a_rev++)
{
a_for = a_rev -> sister;
if (a_for->r_rev_cap)
{
j = NEIGHBOR_NODE_REV(i, a_for -> shift);
if (!j->parent)
{
j -> is_sink = 0;
j -> parent = a_for;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
set_active(j);
}
else if (j->is_sink)
{
s_start = i;
t_start = j;
cap_middle = & ( a_for -> r_rev_cap );
rev_cap_middle = & ( a_for -> r_cap );
break;
}
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the source shorter */
j -> parent = a_for;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
}
}
}
}
else
{
/* grow sink tree */
for (a_for=a_for_first; a_for<a_for_last; a_for++)
if (a_for->r_rev_cap)
{
j = NEIGHBOR_NODE(i, a_for -> shift);
if (!j->parent)
{
j -> is_sink = 1;
j -> parent = MAKE_ODD(a_for);
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
set_active(j);
}
else if (!j->is_sink)
{
s_start = j;
t_start = i;
cap_middle = & ( a_for -> r_rev_cap );
rev_cap_middle = & ( a_for -> r_cap );
break;
}
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the sink shorter */
j -> parent = MAKE_ODD(a_for);
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
}
}
for (a_rev=a_rev_first; a_rev<a_rev_last; a_rev++)
{
a_for = a_rev -> sister;
if (a_for->r_cap)
{
j = NEIGHBOR_NODE_REV(i, a_for -> shift);
if (!j->parent)
{
j -> is_sink = 1;
j -> parent = a_for;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
set_active(j);
}
else if (!j->is_sink)
{
s_start = j;
t_start = i;
cap_middle = & ( a_for -> r_cap );
rev_cap_middle = & ( a_for -> r_rev_cap );
break;
}
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the sink shorter */
j -> parent = a_for;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
}
}
}
}
TIME ++;
if (s_start)
{
i -> next = i; /* set active flag */
current_node = i;
/* augmentation */
augment(s_start, t_start, cap_middle, rev_cap_middle);
/* augmentation end */
/* adoption */
while ((np=orphan_first))
{
np_next = np -> next;
np -> next = NULL;
while ((np=orphan_first))
{
orphan_first = np -> next;
i = np -> ptr;
nodeptr_block -> Delete(np);
if (!orphan_first) orphan_last = NULL;
if (i->is_sink) process_sink_orphan(i);
else process_source_orphan(i);
}
orphan_first = np_next;
}
/* adoption end */
}
else current_node = NULL;
}
delete nodeptr_block;
return flow;
}
void MENUS::on_render()
{
/*
// text rendering test stuff
render_background();
TEXT_CURSOR cursor;
gfx_text_set_cursor(&cursor, 10, 10, 20, TEXTFLAG_RENDER);
gfx_text_ex(&cursor, "ようこそ - ガイド", -1);
gfx_text_set_cursor(&cursor, 10, 30, 15, TEXTFLAG_RENDER);
gfx_text_ex(&cursor, "ようこそ - ガイド", -1);
//gfx_texture_set(-1);
gfx_quads_begin();
gfx_quads_drawTL(60, 60, 5000, 5000);
gfx_quads_end();
return;*/
if(client_state() != CLIENTSTATE_ONLINE && client_state() != CLIENTSTATE_DEMOPLAYBACK)
set_active(true);
if(client_state() == CLIENTSTATE_DEMOPLAYBACK)
{
RECT screen = *ui_screen();
gfx_mapscreen(screen.x, screen.y, screen.w, screen.h);
render_demoplayer(screen);
}
if(client_state() == CLIENTSTATE_ONLINE && gameclient.servermode == gameclient.SERVERMODE_PUREMOD)
{
client_disconnect();
set_active(true);
popup = POPUP_PURE;
}
if(!is_active())
{
escape_pressed = false;
enter_pressed = false;
num_inputevents = 0;
return;
}
// update colors
vec3 rgb = hsl_to_rgb(vec3(config.ui_color_hue/255.0f, config.ui_color_sat/255.0f, config.ui_color_lht/255.0f));
gui_color = vec4(rgb.r, rgb.g, rgb.b, config.ui_color_alpha/255.0f);
color_tabbar_inactive_outgame = vec4(0,0,0,0.25f);
color_tabbar_active_outgame = vec4(0,0,0,0.5f);
float color_ingame_scale_i = 0.5f;
float color_ingame_scale_a = 0.2f;
color_tabbar_inactive_ingame = vec4(
gui_color.r*color_ingame_scale_i,
gui_color.g*color_ingame_scale_i,
gui_color.b*color_ingame_scale_i,
gui_color.a*0.8f);
color_tabbar_active_ingame = vec4(
gui_color.r*color_ingame_scale_a,
gui_color.g*color_ingame_scale_a,
gui_color.b*color_ingame_scale_a,
gui_color.a);
// update the ui
RECT *screen = ui_screen();
float mx = (mouse_pos.x/(float)gfx_screenwidth())*screen->w;
float my = (mouse_pos.y/(float)gfx_screenheight())*screen->h;
int buttons = 0;
if(inp_key_pressed(KEY_MOUSE_1)) buttons |= 1;
if(inp_key_pressed(KEY_MOUSE_2)) buttons |= 2;
if(inp_key_pressed(KEY_MOUSE_3)) buttons |= 4;
ui_update(mx,my,mx*3.0f,my*3.0f,buttons);
// render
if(client_state() != CLIENTSTATE_DEMOPLAYBACK)
render();
// render cursor
gfx_texture_set(data->images[IMAGE_CURSOR].id);
gfx_quads_begin();
gfx_setcolor(1,1,1,1);
gfx_quads_drawTL(mx,my,24,24);
gfx_quads_end();
// render debug information
if(config.debug)
{
RECT screen = *ui_screen();
gfx_mapscreen(screen.x, screen.y, screen.w, screen.h);
char buf[512];
str_format(buf, sizeof(buf), "%p %p %p", ui_hot_item(), ui_active_item(), ui_last_active_item());
TEXT_CURSOR cursor;
gfx_text_set_cursor(&cursor, 10, 10, 10, TEXTFLAG_RENDER);
gfx_text_ex(&cursor, buf, -1);
}
escape_pressed = false;
enter_pressed = false;
num_inputevents = 0;
}
void Graph::process_sink_orphan(node *i)
{
node *j;
arc_forward *a0_for, *a0_for_first, *a0_for_last;
arc_reverse *a0_rev, *a0_rev_first, *a0_rev_last;
arc_forward *a0_min = NULL, *a;
nodeptr *np;
int d, d_min = INFINITE_D;
/* trying to find a new parent */
a0_for_first = i -> first_out;
if (IS_ODD(a0_for_first))
{
a0_for_first = (arc_forward *) (((char *)a0_for_first) + 1);
a0_for_last = (arc_forward *) ((a0_for_first ++) -> shift);
}
else a0_for_last = (i + 1) -> first_out;
a0_rev_first = i -> first_in;
if (IS_ODD(a0_rev_first))
{
a0_rev_first = (arc_reverse *) (((char *)a0_rev_first) + 1);
a0_rev_last = (arc_reverse *) ((a0_rev_first ++) -> sister);
}
else a0_rev_last = (i + 1) -> first_in;
for (a0_for=a0_for_first; a0_for<a0_for_last; a0_for++)
if (a0_for->r_cap)
{
j = NEIGHBOR_NODE(i, a0_for -> shift);
if (j->is_sink && (a=j->parent))
{
/* checking the origin of j */
d = 0;
while ( 1 )
{
if (j->TS == TIME)
{
d += j -> DIST;
break;
}
a = j -> parent;
d ++;
if (a==TERMINAL)
{
j -> TS = TIME;
j -> DIST = 1;
break;
}
if (a==ORPHAN) { d = INFINITE_D; break; }
if (IS_ODD(a))
j = NEIGHBOR_NODE_REV(j, MAKE_EVEN(a) -> shift);
else
j = NEIGHBOR_NODE(j, a -> shift);
}
if (d<INFINITE_D) /* j originates from the sink - done */
{
if (d<d_min)
{
a0_min = a0_for;
d_min = d;
}
/* set marks along the path */
for (j=NEIGHBOR_NODE(i, a0_for->shift); j->TS!=TIME; )
{
j -> TS = TIME;
j -> DIST = d --;
a = j->parent;
if (IS_ODD(a))
j = NEIGHBOR_NODE_REV(j, MAKE_EVEN(a) -> shift);
else
j = NEIGHBOR_NODE(j, a -> shift);
}
}
}
}
for (a0_rev=a0_rev_first; a0_rev<a0_rev_last; a0_rev++)
{
a0_for = a0_rev -> sister;
if (a0_for->r_rev_cap)
{
j = NEIGHBOR_NODE_REV(i, a0_for -> shift);
if (j->is_sink && (a=j->parent))
{
/* checking the origin of j */
d = 0;
while ( 1 )
{
if (j->TS == TIME)
{
d += j -> DIST;
break;
}
a = j -> parent;
d ++;
if (a==TERMINAL)
{
j -> TS = TIME;
j -> DIST = 1;
break;
}
if (a==ORPHAN) { d = INFINITE_D; break; }
if (IS_ODD(a))
j = NEIGHBOR_NODE_REV(j, MAKE_EVEN(a) -> shift);
else
j = NEIGHBOR_NODE(j, a -> shift);
}
if (d<INFINITE_D) /* j originates from the sink - done */
{
if (d<d_min)
{
a0_min = MAKE_ODD(a0_for);
d_min = d;
}
/* set marks along the path */
for (j=NEIGHBOR_NODE_REV(i,a0_for->shift); j->TS!=TIME; )
{
j -> TS = TIME;
j -> DIST = d --;
a = j->parent;
if (IS_ODD(a))
j = NEIGHBOR_NODE_REV(j, MAKE_EVEN(a) -> shift);
else
j = NEIGHBOR_NODE(j, a -> shift);
}
}
}
}
}
if ((i->parent = a0_min))
{
i -> TS = TIME;
i -> DIST = d_min + 1;
}
else
{
/* no parent is found */
i -> TS = 0;
/* process neighbors */
for (a0_for=a0_for_first; a0_for<a0_for_last; a0_for++)
{
j = NEIGHBOR_NODE(i, a0_for -> shift);
if (j->is_sink && (a=j->parent))
{
if (a0_for->r_cap) set_active(j);
if (a!=TERMINAL && a!=ORPHAN && IS_ODD(a) && NEIGHBOR_NODE_REV(j, MAKE_EVEN(a)->shift)==i)
{
/* add j to the adoption list */
j -> parent = ORPHAN;
np = nodeptr_block -> New();
np -> ptr = j;
if (orphan_last) orphan_last -> next = np;
else orphan_first = np;
orphan_last = np;
np -> next = NULL;
}
}
}
for (a0_rev=a0_rev_first; a0_rev<a0_rev_last; a0_rev++)
{
a0_for = a0_rev -> sister;
j = NEIGHBOR_NODE_REV(i, a0_for -> shift);
if (j->is_sink && (a=j->parent))
{
if (a0_for->r_rev_cap) set_active(j);
if (a!=TERMINAL && a!=ORPHAN && !IS_ODD(a) && NEIGHBOR_NODE(j, a->shift)==i)
{
/* add j to the adoption list */
j -> parent = ORPHAN;
np = nodeptr_block -> New();
np -> ptr = j;
if (orphan_last) orphan_last -> next = np;
else orphan_first = np;
orphan_last = np;
np -> next = NULL;
}
}
}
}
}
HGTalkRempassButton::HGTalkRempassButton()
{
set_label(HGTALK_REMPASS);
set_active(g_pHGTalkApp->get_config()->get_rempass());
}
void Visualization_layer::deactivate() {
set_active(false);
}
int
ui_menu_item_set_active( const char *path, int active )
{
return set_active( widget_menu, path, active );
}
void QPBO<REAL>::process_sink_orphan(Node *i)
{
Node *j;
Arc *a0, *a0_min = NULL, *a;
int d, d_min = INFINITE_D;
/* trying to find a new parent */
for (a0=i->first; a0; a0=a0->next)
if (a0->r_cap)
{
j = a0 -> head;
if ((a=j->parent) && j->is_sink)
{
/* checking the origin of j */
d = 0;
while ( 1 )
{
if (j->TS == TIME)
{
d += j -> DIST;
break;
}
a = j -> parent;
d ++;
if (a==QPBO_MAXFLOW_TERMINAL)
{
j -> TS = TIME;
j -> DIST = 1;
break;
}
if (a==QPBO_MAXFLOW_ORPHAN) { d = INFINITE_D; break; }
j = a -> head;
}
if (d<INFINITE_D) /* j originates from the sink - done */
{
if (d<d_min)
{
a0_min = a0;
d_min = d;
}
/* set marks along the path */
for (j=a0->head; j->TS!=TIME; j=j->parent->head)
{
j -> TS = TIME;
j -> DIST = d --;
}
}
}
}
if (i->parent = a0_min)
{
i -> TS = TIME;
i -> DIST = d_min + 1;
}
else
{
/* no parent is found */
add_to_changed_list(i);
/* process neighbors */
for (a0=i->first; a0; a0=a0->next)
{
j = a0 -> head;
if ((a=j->parent) && j->is_sink)
{
if (a0->r_cap) set_active(j);
if (a!=QPBO_MAXFLOW_TERMINAL && a!=QPBO_MAXFLOW_ORPHAN && a->head==i)
{
set_orphan_rear(j); // add j to the end of the adoption list
}
}
}
}
}
void UnderlineMenuItem::menu_shown()
{
m_event_freeze = true;
set_active(m_note_addin->get_buffer()->is_active_tag ("underline"));
m_event_freeze = false;
}
void QPBO<REAL>::maxflow(bool reuse_trees, bool _keep_changed_list)
{
Node *i, *j, *current_node = NULL;
Arc *a;
nodeptr *np, *np_next;
if (!nodeptr_block)
{
nodeptr_block = new DBlock<nodeptr>(NODEPTR_BLOCK_SIZE, error_function);
}
if (maxflow_iteration == 0)
{
reuse_trees = false;
_keep_changed_list = false;
}
keep_changed_list = _keep_changed_list;
if (keep_changed_list)
{
if (!changed_list) changed_list = new Block<Node*>(NODEPTR_BLOCK_SIZE, error_function);
}
if (reuse_trees) maxflow_reuse_trees_init();
else maxflow_init();
// main loop
while ( 1 )
{
// test_consistency(current_node);
if ((i=current_node))
{
i -> next = NULL; /* remove active flag */
if (!i->parent) i = NULL;
}
if (!i)
{
if (!(i = next_active())) break;
}
/* growth */
if (!i->is_sink)
{
/* grow source tree */
for (a=i->first; a; a=a->next)
if (a->r_cap)
{
j = a -> head;
if (!j->parent)
{
j -> is_sink = 0;
j -> parent = a -> sister;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
set_active(j);
add_to_changed_list(j);
}
else if (j->is_sink) break;
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the source shorter */
j -> parent = a -> sister;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
}
}
}
else
{
/* grow sink tree */
for (a=i->first; a; a=a->next)
if (a->sister->r_cap)
{
j = a -> head;
if (!j->parent)
{
j -> is_sink = 1;
j -> parent = a -> sister;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
set_active(j);
add_to_changed_list(j);
}
else if (!j->is_sink) { a = a -> sister; break; }
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the sink shorter */
j -> parent = a -> sister;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
}
}
}
TIME ++;
if (a)
{
i -> next = i; /* set active flag */
current_node = i;
/* augmentation */
augment(a);
/* augmentation end */
/* adoption */
while ((np=orphan_first))
{
np_next = np -> next;
np -> next = NULL;
while ((np=orphan_first))
{
orphan_first = np -> next;
i = np -> ptr;
nodeptr_block -> Delete(np);
if (!orphan_first) orphan_last = NULL;
if (i->is_sink) process_sink_orphan(i);
else process_source_orphan(i);
}
orphan_first = np_next;
}
/* adoption end */
}
else current_node = NULL;
}
// test_consistency();
if (!reuse_trees || (maxflow_iteration % 64) == 0)
{
delete nodeptr_block;
nodeptr_block = NULL;
}
maxflow_iteration ++;
}
int ColPalCtx::event_handler( glow_eEvent event, int x, int y, int w, int h)
{
int sts;
int i;
GlowCtx *ctx;
double fx, fy;
int callback = 0;
ctx = this;
// cout << "Event: " << event << endl;
fx = double( x + ctx->mw.offset_x) / ctx->mw.zoom_factor_x;
fy = double( y + ctx->mw.offset_y) / ctx->mw.zoom_factor_y;
callback_object_type = glow_eObjectType_NoObject;
callback_object = 0;
switch ( event) {
case glow_eEvent_MB1Down:
ctx->gdraw->set_click_sensitivity( &ctx->mw, glow_mSensitivity_MB1Click);
break;
case glow_eEvent_MB1Click:
case glow_eEvent_MB1ClickShift:
case glow_eEvent_MB2Click:
sts = 0;
for ( i = 0; i < a.a_size; i++) {
sts = a.a[i]->event_handler( &ctx->mw, event, x, y, fx, fy);
if ( sts == GLOW__NO_PROPAGATE)
break;
}
if ( callback_object_type != glow_eObjectType_NoObject) {
if ( callback_object->type() == glow_eObjectType_GrowText) {
GrowText *text;
char name[32];
text = (GrowText *)callback_object;
text->get_object_name( name);
if ( strncmp( name, "FillText", 8) == 0 &&
event == glow_eEvent_MB1Click) {
set_active( colpal_eActive_FillColor);
}
else if ( strncmp( name, "BorderText", 10) == 0 &&
event == glow_eEvent_MB1Click) {
set_active( colpal_eActive_BorderColor);
}
else if ( strncmp( name, "TextText", 8) == 0 &&
event == glow_eEvent_MB1Click) {
set_active( colpal_eActive_TextColor);
}
else if ( strncmp( name, "ToneEntry", 9) == 0 &&
event == glow_eEvent_MB1Click) {
glow_eDrawTone tone;
sscanf( &name[9], "%d", (int *) &tone);
if ( event_callback[event] &&
sts != GLOW__NO_PROPAGATE)
{
static glow_sEvent e;
e.event = event;
e.any.type = glow_eEventType_ColorTone;
e.any.x_pixel = x;
e.any.y_pixel = y;
e.any.x = 1.0 * (x + mw.offset_x) / mw.zoom_factor_x;
e.any.y = 1.0 * (y + mw.offset_y) / mw.zoom_factor_y;
e.colortone.tone = tone;
event_callback[event]( this, &e);
}
current_tone = (glow_eDrawType) tone;
break;
}
if ( strcmp( name, "ColorEntryBg") == 0) {
if ( event == glow_eEvent_MB1Click) {
current_fill = glow_eDrawType_LineErase;
((GrowRect *)display_fill)->set_fill_color( glow_eDrawType_Color4);
}
else if ( event == glow_eEvent_MB1ClickShift) {
current_text = glow_eDrawType_LineErase;
((GrowRect *)display_text)->set_fill_color( glow_eDrawType_Color4);
}
else {
current_border = glow_eDrawType_LineErase;
((GrowRect *)display_border)->set_fill_color( glow_eDrawType_Color4);
}
callback = 1;
}
}
else if ( callback_object->type() == glow_eObjectType_GrowRect) {
GrowRect *rect;
char name[32];
rect = (GrowRect *)callback_object;
rect->get_object_name( name);
if ( strncmp( name, "FillRect", 8) == 0 &&
event == glow_eEvent_MB1Click) {
set_active( colpal_eActive_FillColor);
}
else if ( strncmp( name, "BorderRect", 10) == 0 &&
event == glow_eEvent_MB1Click) {
set_active( colpal_eActive_BorderColor);
}
else if ( strncmp( name, "TextRect", 8) == 0 &&
event == glow_eEvent_MB1Click) {
set_active( colpal_eActive_TextColor);
}
else if ( strncmp( name, "ToneEntry", 9) == 0 &&
event == glow_eEvent_MB1Click)
{
glow_eDrawTone tone;
sscanf( &name[9], "%d", (int *) &tone);
if ( event_callback[event] &&
sts != GLOW__NO_PROPAGATE) {
static glow_sEvent e;
e.event = event;
e.any.type = glow_eEventType_ColorTone;
e.any.x_pixel = x;
e.any.y_pixel = y;
e.any.x = 1.0 * (x + mw.offset_x) / mw.zoom_factor_x;
e.any.y = 1.0 * (y + mw.offset_y) / mw.zoom_factor_y;
e.colortone.tone = tone;
event_callback[event]( this, &e);
}
current_tone = (glow_eDrawType) tone;
((GrowRect *)active_tone)->set_fill_color(
(glow_eDrawType) tone_color_match( (int)tone));
break;
}
if ( strncmp( name, "ColorEntry", 10) != 0)
break;
if ( strcmp( name, "ColorEntryBg") == 0) {
if ( event == glow_eEvent_MB1Click) {
current_fill = glow_eDrawType_LineErase;
((GrowRect *)display_fill)->set_fill_color( glow_eDrawType_Color4);
}
else if ( event == glow_eEvent_MB1ClickShift) {
current_text = glow_eDrawType_LineErase;
((GrowRect *)display_text)->set_fill_color( glow_eDrawType_Color4);
}
else {
current_border = glow_eDrawType_LineErase;
((GrowRect *)display_border)->set_fill_color( glow_eDrawType_Color4);
}
callback = 1;
}
else {
if ( event == glow_eEvent_MB1Click) {
switch ( active) {
case colpal_eActive_FillColor:
current_fill = rect->fill_drawtype;
break;
case colpal_eActive_BorderColor:
current_border = rect->fill_drawtype;
break;
case colpal_eActive_TextColor:
current_text = rect->fill_drawtype;
break;
}
set_colors();
}
else if ( event == glow_eEvent_MB1ClickShift) {
current_text = rect->fill_drawtype;
set_colors();
}
else {
current_border = rect->fill_drawtype;
set_colors();
}
callback = 1;
}
}
else if ( callback_object->type() == glow_eObjectType_GrowText) {
}
}
break;
case glow_eEvent_Exposure:
int width, height;
gdraw->get_window_size( &mw, &width, &height);
if ( mw.window_width != width || mw.window_height != height) {
mw.window_width = width;
mw.window_height = height;
change_scrollbar();
}
draw( &mw, x, y, x + w, y + h);
break;
default:
;
}
if ( event_callback[event] &&
sts != GLOW__NO_PROPAGATE && callback)
{
static glow_sEvent e;
e.event = event;
e.any.type = glow_eEventType_Object;
e.any.x_pixel = x;
e.any.y_pixel = y;
e.any.x = 1.0 * (x + mw.offset_x) / mw.zoom_factor_x;
e.any.y = 1.0 * (y + mw.offset_y) / mw.zoom_factor_y;
e.object.object_type = callback_object_type;
if ( callback_object_type != glow_eObjectType_NoObject)
e.object.object = callback_object;
event_callback[event]( this, &e);
}
return 1;
}
void do_input(int fd, unsigned char* buf, struct dev_input input)
{
b1 = buf[3];
b2 = buf[4];
b3 = buf[5];
lx = buf[7] - 128;
ly = buf[8] - 128;
rx = buf[9] - 128;
ry = buf[10] - 128;
//deadzones
if (lx > -10 && lx < 10) lx = 0;
if (ly > -10 && ly < 10) ly = 0;
if (rx > -11 && rx < 11) rx = 0;
if (ry > -11 && ry < 11) ry = 0;
//lr3 enable/disable
if ((b1 & SIXAXIS_KEY_L3) && b1 != last_b1)
lr3_axis = !lr3_axis;
if ((b1 & SIXAXIS_KEY_R3) && b1 != last_b1)
lr3_buttons = !lr3_buttons;
last_b1 = b1;
//buttons
if (!input.use_lr3 || (input.use_lr3 && lr3_buttons)) {
//part1
if (last_ib1 != b1) {
if (input.key_select) uinput_send(fd, EV_KEY, input.key_select, b1 & 0x01 ? 1 : 0);
if (input.key_l3) uinput_send(fd, EV_KEY, input.key_l3, b1 & 0x02 ? 1 : 0);
if (input.key_r3) uinput_send(fd, EV_KEY, input.key_r3, b1 & 0x04 ? 1 : 0);
if (input.key_start) uinput_send(fd, EV_KEY, input.key_start, b1 & 0x08 ? 1 : 0);
if (input.key_up) uinput_send(fd, EV_KEY, input.key_up, b1 & 0x10 ? 1 : 0);
if (input.key_right) uinput_send(fd, EV_KEY, input.key_right, b1 & 0x20 ? 1 : 0);
if (input.key_down) uinput_send(fd, EV_KEY, input.key_down, b1 & 0x40 ? 1 : 0);
if (input.key_left) uinput_send(fd, EV_KEY, input.key_left, b1 & 0x80 ? 1 : 0);
}
//part2
if (last_ib2 != b2) {
if (input.key_l2) uinput_send(fd, EV_KEY, input.key_l2, b2 & 0x01 ? 1 : 0);
if (input.key_r2) uinput_send(fd, EV_KEY, input.key_r2, b2 & 0x02 ? 1 : 0);
if (input.key_l1) uinput_send(fd, EV_KEY, input.key_l1, b2 & 0x04 ? 1 : 0);
if (input.key_r1) uinput_send(fd, EV_KEY, input.key_r1, b2 & 0x08 ? 1 : 0);
if (input.key_tri) uinput_send(fd, EV_KEY, input.key_tri, b2 & 0x10 ? 1 : 0);
if (input.key_cir) uinput_send(fd, EV_KEY, input.key_cir, b2 & 0x20 ? 1 : 0);
if (input.key_cro) uinput_send(fd, EV_KEY, input.key_cro, b2 & 0x40 ? 1 : 0);
if (input.key_squ) uinput_send(fd, EV_KEY, input.key_squ, b2 & 0x80 ? 1 : 0);
}
//part3
if (last_ib3 != b3) {
if (input.key_ps) uinput_send(fd, EV_KEY, input.key_ps, b3 & 0x01 ? 1 : 0);
}
}
//axis
if (!input.use_lr3 || (input.use_lr3 && lr3_axis)) {
int rel;
bool rw_do;
if (rw_timer%(input.axis_speed*2) == 0)
rw_do = true;
else
rw_do = false;
if (input.axis_l_type == INPUT_TYPE_KEYS)
{
uinput_send(fd, EV_KEY, input.axis_l_right, (lx > 100));
uinput_send(fd, EV_KEY, input.axis_l_left, (lx < -100));
uinput_send(fd, EV_KEY, input.axis_l_up, (ly > 100));
uinput_send(fd, EV_KEY, input.axis_l_down, (ly < -100));
}
else if (input.axis_l_type == INPUT_TYPE_MOUSE)
{
rel = input.axis_l_right;
if (rel == REL_X || rel == REL_Y) {
uinput_send(fd, EV_REL, rel, lx/4/input.axis_speed);
} else if (rw_do && (rel == REL_WHEEL || rel == REL_HWHEEL)) {
lx = lx/20;
if (rel == REL_WHEEL) lx = -lx; //Inverted
uinput_send(fd, EV_REL, rel, lx);
}
rel = input.axis_l_up;
if (rel == REL_X || rel == REL_Y) {
uinput_send(fd, EV_REL, rel, ly/4/input.axis_speed);
} else if (rw_do && (rel == REL_WHEEL || rel == REL_HWHEEL)) {
ly = ly/20;
if (rel == REL_WHEEL) ly = -ly; //Inverted
uinput_send(fd, EV_REL, rel, ly);
}
}
if (input.axis_r_type == INPUT_TYPE_KEYS)
{
uinput_send(fd, EV_KEY, input.axis_r_right, (rx > 100));
uinput_send(fd, EV_KEY, input.axis_r_left, (rx < -100));
uinput_send(fd, EV_KEY, input.axis_r_up, (ry > 100));
uinput_send(fd, EV_KEY, input.axis_r_down, (ry < -100));
}
else if (input.axis_r_type == INPUT_TYPE_MOUSE)
{
rel = input.axis_r_right;
if (rel == REL_X || rel == REL_Y) {
uinput_send(fd, EV_REL, rel, rx/4/input.axis_speed);
} else if (rw_do && (rel == REL_WHEEL || rel == REL_HWHEEL)) {
rx = rx/20;
if (rel == REL_WHEEL) rx = -rx; //Inverted
uinput_send(fd, EV_REL, rel, rx);
}
rel = input.axis_r_up;
if (rel == REL_X || rel == REL_Y) {
uinput_send(fd, EV_REL, rel, ry/4/input.axis_speed);
} else if (rw_do && (rel == REL_WHEEL || rel == REL_HWHEEL)) {
ry = ry/20;
if (rel == REL_WHEEL) ry = -ry; //Inverted
uinput_send(fd, EV_REL, rel, ry);
}
}
}
if (b1 > 0 || b2 > 0 || b3 > 0 || lx != 0 || ly != 0 || rx != 0 || ry != 0) {
set_active(true);
}
last_ib1 = b1;
last_ib2 = b2;
last_ib3 = b3;
uinput_send(fd, EV_SYN, SYN_REPORT, 0);
if (rw_timer > 0xff)
rw_timer = 0;
else
rw_timer += 1;
}
void Data_Elise_Gra_Win::set_line_style(Data_Line_St * dlst)
{
set_active();
_degd->set_line_witdh(dlst->witdh());
set_col(dlst->dcp());
}
void do_joystick(int fd, unsigned char* buf, struct dev_joystick joystick)
{
newH.time = tv.tv_sec + tv.tv_usec*1e-6;
newH.ax = buf[42]<<8 | buf[43];
newH.ay = buf[44]<<8 | buf[45];
newH.az = buf[46]<<8 | buf[47];
if ( ! prev.time ) {
prev.time = newH.time;
prev.ax = newH.ax;
prev.ay = newH.ay;
prev.az = newH.az;
}
dt = newH.time - prev.time; //(time constants were recuced by half)
if (joystick.accon) {
rc_dd = 1.0; // Time constant for highpass filter on acceleration
alpha_dd = rc_dd / (rc_dd+dt);
newH.ddx = alpha_dd*(prev.ddx + (newH.ax-prev.ax)*0.01);
newH.ddy = alpha_dd*(prev.ddy + (newH.ay-prev.ay)*0.01);
newH.ddz = alpha_dd*(prev.ddz - (newH.az-prev.az)*0.01);
}
if (joystick.speed) {
rc_d = 1.0; // Time constant for highpass filter on speed
alpha_d = rc_d / (rc_d+dt);
newH.dx = alpha_d*(prev.dx + newH.ddx*dt);
newH.dy = alpha_d*(prev.dy + newH.ddy*dt);
newH.dz = alpha_d*(prev.dz + newH.ddz*dt);
}
if (joystick.pos) {
rc = 0.5; // Time constant for highpass filter on position
alpha = rc / (rc+dt);
newH.x = alpha*(prev.x + newH.dx*dt);
newH.y = alpha*(prev.y + newH.dy*dt);
newH.z = alpha*(prev.z + newH.dz*dt);
}
prev = newH;
b1 = buf[3];
b2 = buf[4];
b3 = buf[5];
lx = buf[7] - 128;
ly = buf[8] - 128;
rx = buf[9] - 128;
ry = buf[10] - 128;
acx = - (buf[42]<<8 | buf[43]); //reversed
acy = buf[44]<<8 | buf[45];
acz = buf[46]<<8 | buf[47];
gyro = 0; // FIXME - What is the gyro suppose to do?
up = buf[15];
right = buf[16];
down = buf[17];
left = buf[18];
l2 = buf[19];
r2 = buf[20];
l1 = buf[21];
r1 = buf[22];
tri = buf[23];
cir = buf[24];
cro = buf[25];
squ = buf[26];
posX = (int)(newH.x*1000);
posY = (int)(newH.y*1000);
posZ = (int)(newH.z*1000);
accX = (int)(newH.ddx*1000);
accY = (int)(newH.ddy*1000);
accZ = (int)(newH.ddz*1000);
velX = (int)(newH.dx*1000);
velY = (int)(newH.dy*1000);
velZ = (int)(newH.dz*1000);
//deadzones
if (lx > -10 && lx < 10) lx = 0;
if (ly > -10 && ly < 10) ly = 0;
if (rx > -11 && rx < 11) rx = 0;
if (ry > -11 && ry < 11) ry = 0;
if (acx < -508 && acx > -516) acx = -512; //acx is reversed
if (acy > 508 && acy < 516) acy = 512;
if (acz > 508 && acz < 516) acz = 512;
if (posX > -30 && posX < 30) posX = 0;
if (posY > -30 && posY < 30) posY = 0;
if (posZ > -30 && posZ < 30) posZ = 0;
if (accX > -30 && accX < 30) accX = 0;
if (accY > -30 && accY < 30) accY = 0;
if (accZ > -30 && accZ < 30) accZ = 0;
if (velX > -30 && velX < 30) velX = 0;
if (velY > -30 && velY < 30) velY = 0;
if (velZ > -30 && velZ < 30) velZ = 0;
if (joystick.buttons) {
//part1
if (last_jb1 != b1) {
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 0, b1 & 0x01 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 1, b1 & 0x02 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 2, b1 & 0x04 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 3, b1 & 0x08 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 4, b1 & 0x10 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 5, b1 & 0x20 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 6, b1 & 0x40 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 7, b1 & 0x80 ? 1 : 0);
}
//part2
if (last_jb2 != b2) {
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 8, b2 & 0x01 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 9, b2 & 0x02 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 10, b2 & 0x04 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 11, b2 & 0x08 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 12, b2 & 0x10 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 13, b2 & 0x20 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 14, b2 & 0x40 ? 1 : 0);
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 15, b2 & 0x80 ? 1 : 0);
}
//part3
if (last_jb3 != b3) {
uinput_send(fd, EV_KEY, BTN_JOYSTICK + 16, b3 & 0x01 ? 1 : 0);
}
if (b1 > 0 || b2 > 0 || b3 > 0) {
set_active(true);
}
}
//axis
if (joystick.axis) {
uinput_send(fd, EV_ABS, 0, lx);
uinput_send(fd, EV_ABS, 1, ly);
uinput_send(fd, EV_ABS, 2, rx);
uinput_send(fd, EV_ABS, 3, ry);
if (lx != 0 || ly != 0 || rx != 0 || ry != 0) {
set_active(true);
}
}
//accelerometer RAW
if (joystick.accel) {
uinput_send(fd, EV_ABS, 4, acx);
uinput_send(fd, EV_ABS, 5, acy);
uinput_send(fd, EV_ABS, 6, acz);
uinput_send(fd, EV_ABS, 7, gyro);
}
//buttons (sensible, as axis)
if (joystick.sbuttons) {
uinput_send(fd, EV_ABS, 8, up);
uinput_send(fd, EV_ABS, 9, right);
uinput_send(fd, EV_ABS, 10, down);
uinput_send(fd, EV_ABS, 11, left);
uinput_send(fd, EV_ABS, 12, l2);
uinput_send(fd, EV_ABS, 13, r2);
uinput_send(fd, EV_ABS, 14, l1);
uinput_send(fd, EV_ABS, 15, r1);
uinput_send(fd, EV_ABS, 16+AXIS_PADDING, tri);
uinput_send(fd, EV_ABS, 17+AXIS_PADDING, cir);
uinput_send(fd, EV_ABS, 18+AXIS_PADDING, cro);
uinput_send(fd, EV_ABS, 19+AXIS_PADDING, squ);
if (up > 0 || right > 0 || down > 0 || left > 0 || l2 > 0 || r2 > 0 || l1 > 0 || r1 > 0 || tri > 0 || cir > 0 || cro > 0 || squ > 0 ) {
set_active(true);
}
}
//acceleration
if (joystick.accon) {
uinput_send(fd, EV_ABS, 20+AXIS_PADDING, accX);
uinput_send(fd, EV_ABS, 21+AXIS_PADDING, accY);
uinput_send(fd, EV_ABS, 22+AXIS_PADDING, accZ);
}
//speed
if (joystick.speed) {
uinput_send(fd, EV_ABS, 23+AXIS_PADDING, velX);
uinput_send(fd, EV_ABS, 24+AXIS_PADDING, velY);
uinput_send(fd, EV_ABS, 25+AXIS_PADDING, velZ);
}
//position
if (joystick.pos) {
uinput_send(fd, EV_ABS, 26+AXIS_PADDING, posX);
uinput_send(fd, EV_ABS, 27+AXIS_PADDING, posY);
uinput_send(fd, EV_ABS, 28+AXIS_PADDING, posZ);
}
last_jb1 = b1;
last_jb2 = b2;
last_jb3 = b3;
uinput_send(fd, EV_SYN, SYN_REPORT, 0);
}
bool Tween::start() {
set_active(true);
_set_process(true);
return true;
}
bool
Xbox360WirelessController::parse(uint8_t* data, int len, XboxGenericMsg* msg_out)
{
if (len == 0)
{
return false;
}
else
{
if (len == 2 && data[0] == 0x08)
{ // Connection Status Message
if (data[1] == 0x00)
{
log_info("connection status: nothing");
// reset the controller into neutral position on disconnect
memset(msg_out, 0, sizeof(*msg_out));
set_active(false);
return true;
}
else if (data[1] == 0x80)
{
log_info("connection status: controller connected");
set_led(get_led());
set_active(true);
}
else if (data[1] == 0x40)
{
log_info("Connection status: headset connected");
}
else if (data[1] == 0xc0)
{
log_info("Connection status: controller and headset connected");
set_led(get_led());
}
else
{
log_info("Connection status: unknown");
}
}
else if (len == 29)
{
set_active(true);
if (data[0] == 0x00 && data[1] == 0x0f && data[2] == 0x00 && data[3] == 0xf0)
{ // Initial Announc Message
m_serial = (boost::format("%2x:%2x:%2x:%2x:%2x:%2x:%2x")
% int(data[7])
% int(data[8])
% int(data[9])
% int(data[10])
% int(data[11])
% int(data[12])
% int(data[13])).str();
m_battery_status = data[17];
log_info("Serial: " << m_serial);
log_info("Battery Status: " << m_battery_status);
}
else if (data[0] == 0x00 && data[1] == 0x01 && data[2] == 0x00 && data[3] == 0xf0 && data[4] == 0x00 && data[5] == 0x13)
{ // Event message
msg_out->type = XBOX_MSG_XBOX360;
Xbox360Msg& msg = msg_out->xbox360;
uint8_t* ptr = data+4;
msg.type = ptr[0];
msg.length = ptr[1];
msg.dpad_up = unpack::bit(ptr+2, 0);
msg.dpad_down = unpack::bit(ptr+2, 1);
msg.dpad_left = unpack::bit(ptr+2, 2);
msg.dpad_right = unpack::bit(ptr+2, 3);
msg.start = unpack::bit(ptr+2, 4);
msg.back = unpack::bit(ptr+2, 5);
msg.thumb_l = unpack::bit(ptr+2, 6);
msg.thumb_r = unpack::bit(ptr+2, 7);
msg.lb = unpack::bit(ptr+3, 0);
msg.rb = unpack::bit(ptr+3, 1);
msg.guide = unpack::bit(ptr+3, 2);
msg.dummy1 = unpack::bit(ptr+3, 3);
msg.a = unpack::bit(ptr+3, 4);
msg.b = unpack::bit(ptr+3, 5);
msg.x = unpack::bit(ptr+3, 6);
msg.y = unpack::bit(ptr+3, 7);
msg.lt = ptr[4];
msg.rt = ptr[5];
msg.x1 = unpack::int16le(ptr+6);
msg.y1 = unpack::int16le(ptr+8);
msg.x2 = unpack::int16le(ptr+10);
msg.y2 = unpack::int16le(ptr+12);
msg.dummy2 = unpack::int32le(ptr+14);
msg.dummy3 = unpack::int16le(ptr+18);
return true;
}
else if (data[0] == 0x00 && data[1] == 0x00 && data[2] == 0x00 && data[3] == 0x13)
{ // Battery status
m_battery_status = data[4];
log_info("battery status: " << m_battery_status);
}
else if (data[0] == 0x00 && data[1] == 0x00 && data[2] == 0x00 && data[3] == 0xf0)
{
// 0x00 0x00 0x00 0xf0 0x00 ... is send after each button
// press, doesn't seem to contain any information
}
else
{
log_debug("unknown: " << raw2str(data, len));
}
}
else
{
log_debug("unknown: " << raw2str(data, len));
}
}
return false;
}
void Renderer::renderclient(Mailbox in) {
FpsCounter fpsc(20);
fpsc.start();
for (auto& cmd : gua::concurrent::pull_items_range<Item, Mailbox>(in)) {
auto window_name(cmd.serialized_cam->config.get_output_window_name());
if (window_name != "") {
auto window = WindowDatabase::instance()->lookup(window_name);
if (window && !window->get_is_open()) {
window->open();
}
// update window if one is assigned
if (window && window->get_is_open()) {
window->set_active(true);
window->start_frame();
if (window->get_context()->framecount == 0) {
display_loading_screen(*window);
}
// make sure pipeline was created
std::shared_ptr<Pipeline> pipe = nullptr;
auto pipe_iter = window->get_context()->render_pipelines.find(
cmd.serialized_cam->uuid);
if (pipe_iter == window->get_context()->render_pipelines.end()) {
pipe = std::make_shared<Pipeline>(
*window->get_context(),
cmd.serialized_cam->config.get_resolution());
window->get_context()->render_pipelines.insert(
std::make_pair(cmd.serialized_cam->uuid, pipe));
} else {
pipe = pipe_iter->second;
}
window->rendering_fps = fpsc.fps;
if (cmd.serialized_cam->config.get_enable_stereo()) {
if (window->config.get_stereo_mode() == StereoMode::NVIDIA_3D_VISION) {
#ifdef GUACAMOLE_ENABLE_NVIDIA_3D_VISION
if ((window->get_context()->framecount % 2) == 0) {
auto img(pipe->render_scene(CameraMode::LEFT, *cmd.serialized_cam, *cmd.scene_graphs));
if (img) window->display(img, true);
} else {
auto img(pipe->render_scene(CameraMode::RIGHT, *cmd.serialized_cam, *cmd.scene_graphs));
if (img) window->display(img, false);
}
#else
Logger::LOG_WARNING << "guacamole has not been compiled with NVIDIA 3D Vision support!" << std::endl;
#endif
} else {
// TODO: add alternate frame rendering here? -> take clear and render methods
auto img(pipe->render_scene(CameraMode::LEFT, *cmd.serialized_cam, *cmd.scene_graphs));
if (img) window->display(img, true);
img = pipe->render_scene(CameraMode::RIGHT, *cmd.serialized_cam, *cmd.scene_graphs);
if (img) window->display(img, false);
}
} else {
auto img(pipe->render_scene(cmd.serialized_cam->config.get_mono_mode(),
*cmd.serialized_cam, *cmd.scene_graphs));
if (img) window->display(img, cmd.serialized_cam->config.get_mono_mode() != CameraMode::RIGHT);
}
pipe->clear_frame_cache();
// swap buffers
window->finish_frame();
++(window->get_context()->framecount);
fpsc.step();
}
}
}
}
bool AnimationTree::_update_caches(AnimationPlayer *player) {
setup_pass++;
if (!player->has_node(player->get_root())) {
ERR_PRINT("AnimationTree: AnimationPlayer root is invalid.");
set_active(false);
return false;
}
Node *parent = player->get_node(player->get_root());
List<StringName> sname;
player->get_animation_list(&sname);
for (List<StringName>::Element *E = sname.front(); E; E = E->next()) {
Ref<Animation> anim = player->get_animation(E->get());
for (int i = 0; i < anim->get_track_count(); i++) {
NodePath path = anim->track_get_path(i);
Animation::TrackType track_type = anim->track_get_type(i);
TrackCache *track = NULL;
if (track_cache.has(path)) {
track = track_cache.get(path);
}
//if not valid, delete track
if (track && (track->type != track_type || ObjectDB::get_instance(track->object_id) == NULL)) {
playing_caches.erase(track);
memdelete(track);
track_cache.erase(path);
track = NULL;
}
if (!track) {
RES resource;
Vector<StringName> leftover_path;
Node *child = parent->get_node_and_resource(path, resource, leftover_path);
if (!child) {
ERR_PRINTS("AnimationTree: '" + String(E->get()) + "', couldn't resolve track: '" + String(path) + "'");
continue;
}
if (!child->is_connected("tree_exited", this, "_node_removed")) {
child->connect("tree_exited", this, "_node_removed", varray(child));
}
switch (track_type) {
case Animation::TYPE_VALUE: {
TrackCacheValue *track_value = memnew(TrackCacheValue);
if (resource.is_valid()) {
track_value->object = resource.ptr();
} else {
track_value->object = child;
}
track_value->subpath = leftover_path;
track_value->object_id = track_value->object->get_instance_id();
track = track_value;
} break;
case Animation::TYPE_TRANSFORM: {
Spatial *spatial = Object::cast_to<Spatial>(child);
if (!spatial) {
ERR_PRINTS("AnimationTree: '" + String(E->get()) + "', transform track does not point to spatial: '" + String(path) + "'");
continue;
}
TrackCacheTransform *track_xform = memnew(TrackCacheTransform);
track_xform->spatial = spatial;
track_xform->skeleton = NULL;
track_xform->bone_idx = -1;
if (path.get_subname_count() == 1 && Object::cast_to<Skeleton>(spatial)) {
Skeleton *sk = Object::cast_to<Skeleton>(spatial);
int bone_idx = sk->find_bone(path.get_subname(0));
if (bone_idx != -1 && !sk->is_bone_ignore_animation(bone_idx)) {
track_xform->skeleton = sk;
track_xform->bone_idx = bone_idx;
}
}
track_xform->object = spatial;
track_xform->object_id = track_xform->object->get_instance_id();
track = track_xform;
} break;
case Animation::TYPE_METHOD: {
TrackCacheMethod *track_method = memnew(TrackCacheMethod);
if (resource.is_valid()) {
track_method->object = resource.ptr();
} else {
track_method->object = child;
}
track_method->object_id = track_method->object->get_instance_id();
track = track_method;
} break;
case Animation::TYPE_BEZIER: {
TrackCacheBezier *track_bezier = memnew(TrackCacheBezier);
if (resource.is_valid()) {
track_bezier->object = resource.ptr();
} else {
track_bezier->object = child;
}
track_bezier->subpath = leftover_path;
track_bezier->object_id = track_bezier->object->get_instance_id();
track = track_bezier;
} break;
case Animation::TYPE_AUDIO: {
TrackCacheAudio *track_audio = memnew(TrackCacheAudio);
track_audio->object = child;
track_audio->object_id = track_audio->object->get_instance_id();
track = track_audio;
} break;
case Animation::TYPE_ANIMATION: {
TrackCacheAnimation *track_animation = memnew(TrackCacheAnimation);
track_animation->object = child;
track_animation->object_id = track_animation->object->get_instance_id();
track = track_animation;
} break;
default: {
ERR_PRINT("Animation corrupted (invalid track type)");
continue;
}
}
track_cache[path] = track;
}
track->setup_pass = setup_pass;
}
}
List<NodePath> to_delete;
const NodePath *K = NULL;
while ((K = track_cache.next(K))) {
TrackCache *tc = track_cache[*K];
if (tc->setup_pass != setup_pass) {
to_delete.push_back(*K);
}
}
while (to_delete.front()) {
NodePath np = to_delete.front()->get();
memdelete(track_cache[np]);
track_cache.erase(np);
to_delete.pop_front();
}
state.track_map.clear();
K = NULL;
int idx = 0;
while ((K = track_cache.next(K))) {
state.track_map[*K] = idx;
idx++;
}
state.track_count = idx;
cache_valid = true;
return true;
}
void Input::ProcessInput(InputManager* input)
{
if (!input) {
return;
}
// bool push_mouse_left = (input->GetMouseLeftCount() > 0);
// bool first_key_shift = (input->GetKeyCount(KEY_INPUT_RSHIFT) == 1
// || input->GetKeyCount(KEY_INPUT_LSHIFT) == 1);
bool push_key_shift = (input->GetKeyCount(KEY_INPUT_RSHIFT) > 0
|| input->GetKeyCount(KEY_INPUT_LSHIFT) > 0);
bool push_key_v = (input->GetKeyCount(KEY_INPUT_V) > 0);
bool push_key_ctrl = (input->GetKeyCount(KEY_INPUT_LCONTROL) > 0
|| input->GetKeyCount(KEY_INPUT_RCONTROL) > 0);
bool push_key_return = (input->GetKeyCount(KEY_INPUT_RETURN) > 0);
bool first_key_return = (input->GetKeyCount(KEY_INPUT_RETURN) == 1);
bool push_repeat_key_return = (input->GetKeyCount(KEY_INPUT_RETURN)
+ KEY_REPEAT_FRAME) % (KEY_REPEAT_FRAME + 1) == 0;
bool push_repeat_key_up = (input->GetKeyCount(KEY_INPUT_UP)
+ KEY_REPEAT_FRAME) % (KEY_REPEAT_FRAME + 1) == 0;
bool push_repeat_key_down = (input->GetKeyCount(KEY_INPUT_DOWN)
+ KEY_REPEAT_FRAME) % (KEY_REPEAT_FRAME + 1) == 0;
// bool push_long_backspace = (input->GetKeyCount(KEY_INPUT_BACK) > 60 * 1.5);
auto input_text = text();
if (!active() && push_key_v && push_key_ctrl) {
set_active(true);
} else {
if (push_key_shift && push_key_return) {
SetActiveKeyInput(input_handle_);
} else if (first_key_return) {
if (CheckKeyInput(input_handle_) == 1) {
if (on_enter_) {
if (on_enter_(unicode::ToString(input_text))) {
SetKeyInputString(_T(""), input_handle_);
}
}
SetActiveKeyInput(input_handle_);
}
}
}
if (push_repeat_key_up) {
cursor_moveto_y_ = cursor_y_ - font_height_ / 2;
cursor_moveto_x_ = cursor_x_ + 2;
} else if (push_repeat_key_down) {
cursor_moveto_y_ = cursor_y_ + font_height_ + font_height_ / 2;
cursor_moveto_x_ = cursor_x_ + 2;
}
if (push_key_shift && push_repeat_key_return && multiline_) {
auto buffer = text();
uint32_t pos = GetKeyInputCursorPosition(input_handle_);
tstring cursor_front_str = buffer.substr(0, pos); // カーソル前の文字列
tstring cursor_back_str = buffer.substr(pos); // カーソル後の文字列
auto new_string = cursor_front_str + _T('\n') + cursor_back_str;
SetKeyInputString(new_string.c_str(), input_handle_);
SetKeyInputCursorPosition(pos + 1, input_handle_);
CancelSelect();
cursor_drag_count_ = 0;
}
int cursor_byte_pos, cursor_dot_pos;
int draw_dot_pos = 0;
TCHAR String[TEXT_BUFFER_SIZE];
GetKeyInputString(String, input_handle_);
// 単一行設定の時、最初の行だけを表示
if (!multiline_) {
tstring buffer(String, _tcslen(String));
size_t pos;
if ((pos = buffer.find(_T('\n'))) != std::string::npos) {
SetKeyInputString(buffer.substr(0, pos).c_str(), input_handle_);
}
}
int internal_width = width_ - INPUT_MARGIN_X * 2;
// int internal_height = height_ - INPUT_MARGIN * 2;
message_lines_.clear();
if (message_.size() > 0) {
int current_line = 0;
tstring line_buffer;
int line_width = 0;
int char_count = 0;
for (auto it = message_.begin(); it != message_.end(); ++it) {
#ifdef UNICODE
TCHAR c = *it;
int width = GetDrawStringWidthToHandle(&c, 1, font_handle_);
line_buffer += c;
char_count++;
#else
unsigned char c = *it;
TCHAR string[2] = { 0, 0 };
int width = 0;
if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)) {
string[0] = c;
string[1] = *(it + 1);
++it;
width = GetDrawStringWidthToHandle(string, 2, font_handle_);
line_buffer += string[0];
line_buffer += string[1];
char_count += 2;
} else if (c == '\n') {
char_count++;
} else {
string[0] = c;
width = GetDrawStringWidthToHandle(string, 1, font_handle_);
line_buffer += string[0];
char_count++;
}
#endif
line_width += width;
if (c == _T('\n')
|| line_width > internal_width - font_height_ / 2) {
if (!line_buffer.empty() && line_buffer.back() == _T('\n')) {
line_buffer.pop_back();
}
message_lines_.push_back(line_buffer);
current_line++;
line_buffer.clear();
line_width = 0;
}
}
message_lines_.push_back(line_buffer);
}
if (active()) {
// カーソル位置（byte）を取得
cursor_byte_pos = GetKeyInputCursorPosition(input_handle_);
if (prev_cursor_pos_ != cursor_byte_pos) {
ResetCursorCount();
}
prev_cursor_pos_ = cursor_byte_pos;
// カーソルのドット単位の位置を取得する
cursor_dot_pos = GetDrawStringWidthToHandle(String, cursor_byte_pos,
font_handle_);
draw_dot_pos += cursor_dot_pos;
tstring cursor_front_str(String, cursor_byte_pos); // カーソル前の文字列
tstring cursor_back_str(String + cursor_byte_pos); // カーソル後の文字列
std::vector<tstring> clauses; // 入力中の文節
std::vector<tstring> candidates; // 変換候補
lines_.clear();
selecting_lines_.clear();
clause_lines_.clear();
selecting_clause_lines_.clear();
candidates_.clear();
// 文節データを取得
// int selecting_clause = -1;
selecting_candidate_ = -1;
IMEINPUTDATA *ImeData = GetIMEInputData();
if (ImeData && active()) {
for (int i = 0; i < ImeData->ClauseNum; i++) {
clauses.push_back(
tstring(
ImeData->InputString
+ ImeData->ClauseData[i].Position,
ImeData->ClauseData[i].Length));
}
selecting_clause_ = ImeData->SelectClause;
if (ImeData->CandidateNum > 0) {
for (int i = 0; i < ImeData->CandidateNum; i++) {
candidates_.push_back(
tstring(ImeData->CandidateList[i],
_tcslen(ImeData->CandidateList[i])));
}
selecting_candidate_ = ImeData->SelectCandidate;
}
}
// 選択範囲を取得
int select_start, select_end;
GetKeyInputSelectArea(&select_start, &select_end, input_handle_);
if (select_start > select_end) {
std::swap(select_start, select_end);
}
tstring line_buffer;
int line_width = 0;
int char_count = 0;
// カーソル前のデータを描画
for (auto it = cursor_front_str.begin(); it != cursor_front_str.end();
++it) {
int prev_char_count = char_count;
#ifdef UNICODE
TCHAR c = *it;
int width = GetDrawStringWidthToHandle(&c, 1, font_handle_);
line_buffer += c;
char_count++;
#else
unsigned char c = *it;
TCHAR string[2] = { 0, 0 };
int width = 0;
if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)) {
string[0] = c;
string[1] = *(it + 1);
++it;
width = GetDrawStringWidthToHandle(string, 2, font_handle_);
line_buffer += string[0];
line_buffer += string[1];
char_count += 2;
} else if (c == '\n') {
char_count++;
} else {
string[0] = c;
width = GetDrawStringWidthToHandle(string, 1, font_handle_);
line_buffer += string[0];
char_count++;
}
#endif
// 選択範囲を記録
if (select_start < char_count && char_count <= select_end) {
selecting_lines_.resize(static_cast<int>(lines_.size() + message_lines_.size()) + 1,
std::pair<int, int>(99999, 0));
selecting_lines_[static_cast<int>(lines_.size() + message_lines_.size())].first = std::min(
selecting_lines_[static_cast<int>(lines_.size() + message_lines_.size())].first, line_width);
selecting_lines_[static_cast<int>(lines_.size() + message_lines_.size())].second = std::max(
selecting_lines_[static_cast<int>(lines_.size() + message_lines_.size())].second,
line_width + std::max(width, 3));
}
if (line_width - width / 2 <= cursor_moveto_x_
&& cursor_moveto_x_ <= line_width + width
&& static_cast<int>(lines_.size() + message_lines_.size()) * font_height_ <= cursor_moveto_y_
&& cursor_moveto_y_ <= (static_cast<int>(lines_.size() + message_lines_.size()) + 1) * font_height_) {
SetKeyInputCursorPosition(prev_char_count, input_handle_);
cursor_moveto_x_ = -1;
cursor_moveto_y_ = -1;
}
line_width += width;
if (c == _T('\n') || line_width > internal_width - font_height_ / 2) {
if (!line_buffer.empty() && line_buffer.back() == _T('\n')) {
line_buffer.pop_back();
}
lines_.push_back(line_buffer);
if (cursor_moveto_x_ >= line_width
&& static_cast<int>(lines_.size() + message_lines_.size()) * font_height_ <= cursor_moveto_y_
&& cursor_moveto_y_
<= (static_cast<int>(lines_.size() + message_lines_.size()) + 1) * font_height_) {
if (c == _T('\n')) {
SetKeyInputCursorPosition(char_count - 1,
input_handle_);
} else {
SetKeyInputCursorPosition(char_count, input_handle_);
}
cursor_moveto_x_ = -1;
cursor_moveto_y_ = -1;
}
line_buffer.clear();
line_width = 0;
}
}
cursor_x_ = line_width;
cursor_y_ = static_cast<int>(lines_.size() + message_lines_.size()) * font_height_;
// 変換中データを描画
for (uint32_t index = 0; index < clauses.size(); index++) {
for (auto it = clauses[index].begin(); it != clauses[index].end();
++it) {
#ifdef UNICODE
TCHAR c = *it;
int width = GetDrawStringWidthToHandle(&c, 1, font_handle_);
line_buffer += tstring(&c, 1);
char_count++;
#else
unsigned char c = *it;
TCHAR string[2] = { 0, 0 };
int width = 0;
if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)) {
string[0] = c;
string[1] = *(it + 1);
++it;
width = GetDrawStringWidthToHandle(string, 2, font_handle_);
line_buffer += string[0];
line_buffer += string[1];
char_count += 2;
} else if (c == '\n') {
char_count++;
} else {
string[0] = c;
width = GetDrawStringWidthToHandle(string, 1, font_handle_);
line_buffer += string[0];
char_count++;
}
#endif
clause_lines_.resize(static_cast<int>(lines_.size() + message_lines_.size()) + 1,
std::pair<int, int>(99999, 0));
clause_lines_[static_cast<int>(lines_.size() + message_lines_.size())].first = std::min(
clause_lines_[static_cast<int>(lines_.size() + message_lines_.size())].first, line_width);
clause_lines_[static_cast<int>(lines_.size() + message_lines_.size())].second = std::max(
clause_lines_[static_cast<int>(lines_.size() + message_lines_.size())].second, line_width + width);
if (index == static_cast<uint32_t>(selecting_clause_)) {
selecting_clause_lines_.resize(static_cast<int>(lines_.size() + message_lines_.size()) + 1,
std::pair<int, int>(99999, 0));
selecting_clause_lines_[static_cast<int>(lines_.size() + message_lines_.size())].first = std::min(
selecting_clause_lines_[static_cast<int>(lines_.size() + message_lines_.size())].first,
line_width);
selecting_clause_lines_[static_cast<int>(lines_.size() + message_lines_.size())].second = std::max(
selecting_clause_lines_[static_cast<int>(lines_.size() + message_lines_.size())].second,
line_width + width);
}
line_width += width;
if (line_width > internal_width - font_height_ / 2) {
lines_.push_back(line_buffer);
line_buffer.clear();
line_width = 0;
}
}
}
// カーソル後のデータを描画
for (auto it = cursor_back_str.begin(); it != cursor_back_str.end();
++it) {
int prev_char_count = char_count;
#ifdef UNICODE
TCHAR c = *it;
int width = GetDrawStringWidthToHandle(&c, 1, font_handle_);
line_buffer += tstring(&c, 1);
#else
unsigned char c = *it;
TCHAR string[2] = { 0, 0 };
int width = 0;
if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)) {
string[0] = c;
string[1] = *(it + 1);
++it;
width = GetDrawStringWidthToHandle(string, 2, font_handle_);
line_buffer += string[0];
line_buffer += string[1];
char_count += 2;
} else if (c == '\n') {
char_count++;
} else {
string[0] = c;
width = GetDrawStringWidthToHandle(string, 1, font_handle_);
line_buffer += string[0];
char_count++;
}
#endif
// 選択範囲を記録
if (select_start < char_count && char_count <= select_end) {
selecting_lines_.resize(static_cast<int>(lines_.size() + message_lines_.size()) + 1,
std::pair<int, int>(99999, 0));
selecting_lines_[static_cast<int>(lines_.size() + message_lines_.size())].first = std::min(
selecting_lines_[static_cast<int>(lines_.size() + message_lines_.size())].first, line_width);
selecting_lines_[static_cast<int>(lines_.size() + message_lines_.size())].second = std::max(
selecting_lines_[static_cast<int>(lines_.size() + message_lines_.size())].second,
line_width + std::max(width, 3));
}
if (line_width - width / 2 <= cursor_moveto_x_
&& cursor_moveto_x_ <= line_width + width
&& static_cast<int>(lines_.size() + message_lines_.size()) * font_height_ <= cursor_moveto_y_
&& cursor_moveto_y_ <= (static_cast<int>(lines_.size() + message_lines_.size()) + 1) * font_height_) {
SetKeyInputCursorPosition(prev_char_count, input_handle_);
cursor_moveto_x_ = -1;
cursor_moveto_y_ = -1;
}
line_width += width;
if (c == _T('\n') || line_width > internal_width - font_height_ / 2) {
if (!line_buffer.empty() && line_buffer.back() == _T('\n')) {
line_buffer.pop_back();
}
lines_.push_back(line_buffer);
if (cursor_moveto_x_ >= line_width
&& static_cast<int>(lines_.size() + message_lines_.size()) * font_height_ <= cursor_moveto_y_
&& cursor_moveto_y_
<= (static_cast<int>(lines_.size() + message_lines_.size()) + 1) * font_height_) {
if (c == _T('\n')) {
SetKeyInputCursorPosition(char_count - 1,
input_handle_);
} else {
SetKeyInputCursorPosition(char_count, input_handle_);
}
cursor_moveto_x_ = -1;
cursor_moveto_y_ = -1;
}
line_buffer.clear();
line_width = 0;
}
}
// バッファの残りを描画
lines_.push_back(line_buffer);
if (cursor_moveto_x_ >= line_width
&& static_cast<int>(lines_.size() + message_lines_.size()) * font_height_ <= cursor_moveto_y_
&& static_cast<int>(cursor_moveto_y_) <= static_cast<int>(lines_.size() + message_lines_.size()) * font_height_) {
SetKeyInputCursorPosition(char_count, input_handle_);
cursor_moveto_x_ = -1;
cursor_moveto_y_ = -1;
}
height_ = static_cast<int>(lines_.size() + message_lines_.size()) * font_height_ + INPUT_MARGIN_Y * 2;
// height_ = max(height_, min_height_);
line_buffer.clear();
line_width = 0;
//if (push_key_shift && (push_repeat_key_up || push_repeat_key_down)) {
// SetKeyInputSelectArea(GetKeyInputCursorPosition(input_handle_),
// prev_cursor_pos_, input_handle_);
//}
}
if (active()) {
input->CancelKeyCountAll();
}
}
void AnimationTree::_process_graph(float p_delta) {
_update_properties(); //if properties need updating, update them
//check all tracks, see if they need modification
root_motion_transform = Transform();
if (!root.is_valid()) {
ERR_PRINT("AnimationTree: root AnimationNode is not set, disabling playback.");
set_active(false);
cache_valid = false;
return;
}
if (!has_node(animation_player)) {
ERR_PRINT("AnimationTree: no valid AnimationPlayer path set, disabling playback");
set_active(false);
cache_valid = false;
return;
}
AnimationPlayer *player = Object::cast_to<AnimationPlayer>(get_node(animation_player));
ObjectID current_animation_player = 0;
if (player) {
current_animation_player = player->get_instance_id();
}
if (last_animation_player != current_animation_player) {
if (last_animation_player) {
Object *old_player = ObjectDB::get_instance(last_animation_player);
if (old_player) {
old_player->disconnect("caches_cleared", this, "_clear_caches");
}
}
if (player) {
player->connect("caches_cleared", this, "_clear_caches");
}
last_animation_player = current_animation_player;
}
if (!player) {
ERR_PRINT("AnimationTree: path points to a node not an AnimationPlayer, disabling playback");
set_active(false);
cache_valid = false;
return;
}
if (!cache_valid) {
if (!_update_caches(player)) {
return;
}
}
{ //setup
process_pass++;
state.valid = true;
state.invalid_reasons = "";
state.animation_states.clear(); //will need to be re-created
state.valid = true;
state.player = player;
state.last_pass = process_pass;
state.tree = this;
// root source blends
root->blends.resize(state.track_count);
float *src_blendsw = root->blends.ptrw();
for (int i = 0; i < state.track_count; i++) {
src_blendsw[i] = 1.0; //by default all go to 1 for the root input
}
}
//process
{
if (started) {
//if started, seek
root->_pre_process(SceneStringNames::get_singleton()->parameters_base_path, NULL, &state, 0, true, Vector<StringName>());
started = false;
}
root->_pre_process(SceneStringNames::get_singleton()->parameters_base_path, NULL, &state, p_delta, false, Vector<StringName>());
}
if (!state.valid) {
return; //state is not valid. do nothing.
}
//apply value/transform/bezier blends to track caches and execute method/audio/animation tracks
{
bool can_call = is_inside_tree() && !Engine::get_singleton()->is_editor_hint();
for (List<AnimationNode::AnimationState>::Element *E = state.animation_states.front(); E; E = E->next()) {
const AnimationNode::AnimationState &as = E->get();
Ref<Animation> a = as.animation;
float time = as.time;
float delta = as.delta;
bool seeked = as.seeked;
for (int i = 0; i < a->get_track_count(); i++) {
NodePath path = a->track_get_path(i);
ERR_CONTINUE(!track_cache.has(path));
TrackCache *track = track_cache[path];
if (track->type != a->track_get_type(i)) {
continue; //may happen should not
}
track->root_motion = root_motion_track == path;
ERR_CONTINUE(!state.track_map.has(path));
int blend_idx = state.track_map[path];
ERR_CONTINUE(blend_idx < 0 || blend_idx >= state.track_count);
float blend = (*as.track_blends)[blend_idx];
if (blend < CMP_EPSILON)
continue; //nothing to blend
switch (track->type) {
case Animation::TYPE_TRANSFORM: {
TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
if (track->root_motion) {
if (t->process_pass != process_pass) {
t->process_pass = process_pass;
t->loc = Vector3();
t->rot = Quat();
t->rot_blend_accum = 0;
t->scale = Vector3();
}
float prev_time = time - delta;
if (prev_time < 0) {
if (!a->has_loop()) {
prev_time = 0;
} else {
prev_time = a->get_length() + prev_time;
}
}
Vector3 loc[2];
Quat rot[2];
Vector3 scale[2];
if (prev_time > time) {
Error err = a->transform_track_interpolate(i, prev_time, &loc[0], &rot[0], &scale[0]);
if (err != OK) {
continue;
}
a->transform_track_interpolate(i, a->get_length(), &loc[1], &rot[1], &scale[1]);
t->loc += (loc[1] - loc[0]) * blend;
t->scale += (scale[1] - scale[0]) * blend;
Quat q = Quat().slerp(rot[0].normalized().inverse() * rot[1].normalized(), blend).normalized();
t->rot = (t->rot * q).normalized();
prev_time = 0;
}
Error err = a->transform_track_interpolate(i, prev_time, &loc[0], &rot[0], &scale[0]);
if (err != OK) {
continue;
}
a->transform_track_interpolate(i, time, &loc[1], &rot[1], &scale[1]);
t->loc += (loc[1] - loc[0]) * blend;
t->scale += (scale[1] - scale[0]) * blend;
Quat q = Quat().slerp(rot[0].normalized().inverse() * rot[1].normalized(), blend).normalized();
t->rot = (t->rot * q).normalized();
prev_time = 0;
} else {
Vector3 loc;
Quat rot;
Vector3 scale;
Error err = a->transform_track_interpolate(i, time, &loc, &rot, &scale);
//ERR_CONTINUE(err!=OK); //used for testing, should be removed
if (t->process_pass != process_pass) {
t->process_pass = process_pass;
t->loc = loc;
t->rot = rot;
t->rot_blend_accum = 0;
t->scale = Vector3();
}
scale -= Vector3(1.0, 1.0, 1.0); //helps make it work properly with Add nodes
if (err != OK)
continue;
t->loc = t->loc.linear_interpolate(loc, blend);
if (t->rot_blend_accum == 0) {
t->rot = rot;
t->rot_blend_accum = blend;
} else {
float rot_total = t->rot_blend_accum + blend;
t->rot = rot.slerp(t->rot, t->rot_blend_accum / rot_total).normalized();
t->rot_blend_accum = rot_total;
}
t->scale = t->scale.linear_interpolate(scale, blend);
}
} break;
case Animation::TYPE_VALUE: {
TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
Animation::UpdateMode update_mode = a->value_track_get_update_mode(i);
if (update_mode == Animation::UPDATE_CONTINUOUS || update_mode == Animation::UPDATE_CAPTURE) { //delta == 0 means seek
Variant value = a->value_track_interpolate(i, time);
if (value == Variant())
continue;
if (t->process_pass != process_pass) {
t->value = value;
t->process_pass = process_pass;
}
Variant::interpolate(t->value, value, blend, t->value);
} else if (delta != 0) {
List<int> indices;
a->value_track_get_key_indices(i, time, delta, &indices);
for (List<int>::Element *F = indices.front(); F; F = F->next()) {
Variant value = a->track_get_key_value(i, F->get());
t->object->set_indexed(t->subpath, value);
}
}
} break;
case Animation::TYPE_METHOD: {
if (delta == 0) {
continue;
}
TrackCacheMethod *t = static_cast<TrackCacheMethod *>(track);
List<int> indices;
a->method_track_get_key_indices(i, time, delta, &indices);
for (List<int>::Element *F = indices.front(); F; F = F->next()) {
StringName method = a->method_track_get_name(i, F->get());
Vector<Variant> params = a->method_track_get_params(i, F->get());
int s = params.size();
ERR_CONTINUE(s > VARIANT_ARG_MAX);
if (can_call) {
t->object->call_deferred(
method,
s >= 1 ? params[0] : Variant(),
s >= 2 ? params[1] : Variant(),
s >= 3 ? params[2] : Variant(),
s >= 4 ? params[3] : Variant(),
s >= 5 ? params[4] : Variant());
}
}
} break;
case Animation::TYPE_BEZIER: {
TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
float bezier = a->bezier_track_interpolate(i, time);
if (t->process_pass != process_pass) {
t->value = bezier;
t->process_pass = process_pass;
}
t->value = Math::lerp(t->value, bezier, blend);
} break;
case Animation::TYPE_AUDIO: {
TrackCacheAudio *t = static_cast<TrackCacheAudio *>(track);
if (seeked) {
//find whathever should be playing
int idx = a->track_find_key(i, time);
if (idx < 0)
continue;
Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
if (!stream.is_valid()) {
t->object->call("stop");
t->playing = false;
playing_caches.erase(t);
} else {
float start_ofs = a->audio_track_get_key_start_offset(i, idx);
start_ofs += time - a->track_get_key_time(i, idx);
float end_ofs = a->audio_track_get_key_end_offset(i, idx);
float len = stream->get_length();
if (start_ofs > len - end_ofs) {
t->object->call("stop");
t->playing = false;
playing_caches.erase(t);
continue;
}
t->object->call("set_stream", stream);
t->object->call("play", start_ofs);
t->playing = true;
playing_caches.insert(t);
if (len && end_ofs > 0) { //force a end at a time
t->len = len - start_ofs - end_ofs;
} else {
t->len = 0;
}
t->start = time;
}
} else {
//find stuff to play
List<int> to_play;
a->track_get_key_indices_in_range(i, time, delta, &to_play);
if (to_play.size()) {
int idx = to_play.back()->get();
Ref<AudioStream> stream = a->audio_track_get_key_stream(i, idx);
if (!stream.is_valid()) {
t->object->call("stop");
t->playing = false;
playing_caches.erase(t);
} else {
float start_ofs = a->audio_track_get_key_start_offset(i, idx);
float end_ofs = a->audio_track_get_key_end_offset(i, idx);
float len = stream->get_length();
t->object->call("set_stream", stream);
t->object->call("play", start_ofs);
t->playing = true;
playing_caches.insert(t);
if (len && end_ofs > 0) { //force a end at a time
t->len = len - start_ofs - end_ofs;
} else {
t->len = 0;
}
t->start = time;
}
} else if (t->playing) {
bool loop = a->has_loop();
bool stop = false;
if (!loop && time < t->start) {
stop = true;
} else if (t->len > 0) {
float len = t->start > time ? (a->get_length() - t->start) + time : time - t->start;
if (len > t->len) {
stop = true;
}
}
if (stop) {
//time to stop
t->object->call("stop");
t->playing = false;
playing_caches.erase(t);
}
}
}
float db = Math::linear2db(MAX(blend, 0.00001));
if (t->object->has_method("set_unit_db")) {
t->object->call("set_unit_db", db);
} else {
t->object->call("set_volume_db", db);
}
} break;
case Animation::TYPE_ANIMATION: {
TrackCacheAnimation *t = static_cast<TrackCacheAnimation *>(track);
AnimationPlayer *player2 = Object::cast_to<AnimationPlayer>(t->object);
if (!player2)
continue;
if (delta == 0 || seeked) {
//seek
int idx = a->track_find_key(i, time);
if (idx < 0)
continue;
float pos = a->track_get_key_time(i, idx);
StringName anim_name = a->animation_track_get_key_animation(i, idx);
if (String(anim_name) == "[stop]" || !player2->has_animation(anim_name))
continue;
Ref<Animation> anim = player2->get_animation(anim_name);
float at_anim_pos;
if (anim->has_loop()) {
at_anim_pos = Math::fposmod(time - pos, anim->get_length()); //seek to loop
} else {
at_anim_pos = MAX(anim->get_length(), time - pos); //seek to end
}
if (player2->is_playing() || seeked) {
player2->play(anim_name);
player2->seek(at_anim_pos);
t->playing = true;
playing_caches.insert(t);
} else {
player2->set_assigned_animation(anim_name);
player2->seek(at_anim_pos, true);
}
} else {
//find stuff to play
List<int> to_play;
a->track_get_key_indices_in_range(i, time, delta, &to_play);
if (to_play.size()) {
int idx = to_play.back()->get();
StringName anim_name = a->animation_track_get_key_animation(i, idx);
if (String(anim_name) == "[stop]" || !player2->has_animation(anim_name)) {
if (playing_caches.has(t)) {
playing_caches.erase(t);
player2->stop();
t->playing = false;
}
} else {
player2->play(anim_name);
t->playing = true;
playing_caches.insert(t);
}
}
}
} break;
}
}
}
}
{
// finally, set the tracks
const NodePath *K = NULL;
while ((K = track_cache.next(K))) {
TrackCache *track = track_cache[*K];
if (track->process_pass != process_pass)
continue; //not processed, ignore
switch (track->type) {
case Animation::TYPE_TRANSFORM: {
TrackCacheTransform *t = static_cast<TrackCacheTransform *>(track);
Transform xform;
xform.origin = t->loc;
t->scale += Vector3(1.0, 1.0, 1.0); //helps make it work properly with Add nodes and root motion
xform.basis.set_quat_scale(t->rot, t->scale);
if (t->root_motion) {
root_motion_transform = xform;
if (t->skeleton && t->bone_idx >= 0) {
root_motion_transform = (t->skeleton->get_bone_rest(t->bone_idx) * root_motion_transform) * t->skeleton->get_bone_rest(t->bone_idx).affine_inverse();
}
} else if (t->skeleton && t->bone_idx >= 0) {
t->skeleton->set_bone_pose(t->bone_idx, xform);
} else {
t->spatial->set_transform(xform);
}
} break;
case Animation::TYPE_VALUE: {
TrackCacheValue *t = static_cast<TrackCacheValue *>(track);
t->object->set_indexed(t->subpath, t->value);
} break;
case Animation::TYPE_BEZIER: {
TrackCacheBezier *t = static_cast<TrackCacheBezier *>(track);
t->object->set_indexed(t->subpath, t->value);
} break;
default: {} //the rest don't matter
}
}
}
}
void Graph::process_source_orphan(node *i)
{
node *j;
arc *a0, *a0_min = NULL, *a;
nodeptr *np;
int d, d_min = INFINITE_D;
/* trying to find a new parent */
for (a0=i->first; a0; a0=a0->next)
if (a0->sister->r_cap)
{
j = a0 -> head;
if (!j->is_sink && (a=j->parent))
{
/* checking the origin of j */
d = 0;
while ( 1 )
{
if (j->TS == TIME)
{
d += j -> DIST;
break;
}
a = j -> parent;
d ++;
if (a==TERMINAL)
{
j -> TS = TIME;
j -> DIST = 1;
break;
}
if (a==ORPHAN) {
d = INFINITE_D;
break;
}
j = a -> head;
}
if (d<INFINITE_D) /* j originates from the source - done */
{
if (d<d_min)
{
a0_min = a0;
d_min = d;
}
/* set marks along the path */
for (j=a0->head; j->TS!=TIME; j=j->parent->head)
{
j -> TS = TIME;
j -> DIST = d --;
}
}
}
}
if (i->parent = a0_min)
{
i -> TS = TIME;
i -> DIST = d_min + 1;
}
else
{
/* no parent is found */
i -> TS = 0;
/* process neighbors */
for (a0=i->first; a0; a0=a0->next)
{
j = a0 -> head;
if (!j->is_sink && (a=j->parent))
{
if (a0->sister->r_cap) set_active(j);
if (a!=TERMINAL && a!=ORPHAN && a->head==i)
{
/* add j to the adoption list */
j -> parent = ORPHAN;
np = nodeptr_block -> New();
np -> ptr = j;
if (orphan_last) orphan_last -> next = np;
else orphan_first = np;
orphan_last = np;
np -> next = NULL;
}
}
}
}
}
flowtype Graph<captype,tcaptype,flowtype>::maxflow(bool reuse_trees, Block<node_id>* _changed_list)
{
node *i, *j, *current_node = NULL;
arc *a;
nodeptr *np, *np_next;
if (!nodeptr_block)
{
nodeptr_block = new DBlock<nodeptr>(NODEPTR_BLOCK_SIZE, error_function);
}
changed_list = _changed_list;
if (maxflow_iteration == 0 && reuse_trees) { if (error_function) (*error_function)((char *) "reuse_trees cannot be used in the first call to maxflow()!"); exit(1); }
if (changed_list && !reuse_trees) { if (error_function) (*error_function)((char *) "changed_list cannot be used without reuse_trees!"); exit(1); }
if (reuse_trees) maxflow_reuse_trees_init();
else maxflow_init();
// main loop
while ( 1 )
{
// test_consistency(current_node);
if ((i=current_node))
{
i -> next = NULL; /* remove active flag */
if (!i->parent) i = NULL;
}
if (!i)
{
if (!(i = next_active())) break;
}
/* growth */
if (!i->is_sink)
{
/* grow source tree */
for (a=i->first; a; a=a->next)
if (a->r_cap)
{
j = a -> head;
if (!j->parent)
{
j -> is_sink = 0;
j -> parent = a -> sister;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
set_active(j);
add_to_changed_list(j);
}
else if (j->is_sink) break;
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the source shorter */
j -> parent = a -> sister;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
}
}
}
else
{
/* grow sink tree */
for (a=i->first; a; a=a->next)
if (a->sister->r_cap)
{
j = a -> head;
if (!j->parent)
{
j -> is_sink = 1;
j -> parent = a -> sister;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
set_active(j);
add_to_changed_list(j);
}
else if (!j->is_sink) { a = a -> sister; break; }
else if (j->TS <= i->TS &&
j->DIST > i->DIST)
{
/* heuristic - trying to make the distance from j to the sink shorter */
j -> parent = a -> sister;
j -> TS = i -> TS;
j -> DIST = i -> DIST + 1;
}
}
}
TIME ++;
if (a)
{
i -> next = i; /* set active flag */
current_node = i;
/* augmentation */
augment(a);
/* augmentation end */
/* adoption */
while ((np=orphan_first))
{
np_next = np -> next;
np -> next = NULL;
while ((np=orphan_first))
{
orphan_first = np -> next;
i = np -> ptr;
nodeptr_block -> Delete(np);
if (!orphan_first) orphan_last = NULL;
if (i->is_sink) process_sink_orphan(i);
else process_source_orphan(i);
}
orphan_first = np_next;
}
/* adoption end */
}
else current_node = NULL;
}
// test_consistency();
if (!reuse_trees || (maxflow_iteration % 64) == 0)
{
delete nodeptr_block;
nodeptr_block = NULL;
}
maxflow_iteration ++;
return flow;
}
