//---------------------------------------------------------
/*virtual*/ void ScoreState::handle_event(const SDL_Event& event)
{
point_t mouse_pos(0, 0);
switch(event.type)
{
case SDL_QUIT:
_engine.stop();
break;
case SDL_KEYDOWN:
//_engine.stop();
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
_engine.stop();
break;
case SDLK_y:
//_play_again=true;
//_engine.get_state_mngr()->get_prev_state();
//_engine.get_state_mngr()->top()->init();
break;
case SDLK_n:
//_play_again=false;
//_engine.stop();
break;
default:
break;
}
break;
case SDL_MOUSEMOTION:
mouse_pos=std::make_pair(event.motion.x, event.motion.y);
if(_yes->check_seleted(mouse_pos))
_yes->set_size(3);
else
_yes->set_size(2);
if(_no->check_seleted(mouse_pos))
_no->set_size(3);
else
_no->set_size(2);
break;
case SDL_MOUSEBUTTONDOWN:
if(event.button.button==SDL_BUTTON_LEFT)
{
mouse_pos=std::make_pair(event.motion.x, event.motion.y);
if(_yes->check_seleted(mouse_pos))
{
//pop current state (this)
/*delete*/ _engine.get_state_mngr()->pop(); //FIXME
//re-init PlayingState
_engine.get_state_mngr()->top()->dispose();
_engine.get_state_mngr()->top()->init();
}
if(_no->check_seleted(mouse_pos))
_engine.stop();
}
break;
default:
break;
}
}
bool _get_touch(const Vector2* pos, float radius, Vector2* touch) {
assert(pos);
Touch* touches = touches_get();
if(touches)
{
uint count = touches_count();
for(uint i = 0; i < count; ++i) {
if(vec2_length_sq(vec2_sub(*pos, touches[i].pos)) > radius*radius)
continue;
if(touch)
*touch = touches[i].pos;
return true;
}
}
if(mouse_pressed(MBTN_LEFT)) {
uint x, y;
mouse_pos(&x, &y);
Vector2 mpos = {(float)x, (float)y};
if(vec2_length_sq(vec2_sub(*pos, mpos)) <= radius*radius) {
if(touch)
*touch = mpos;
return true;
}
}
return false;
}
void TooltipManagerWin::OnMouse(UINT u_msg, WPARAM w_param, LPARAM l_param)
{
gfx::Point mouse_pos(l_param);
if(u_msg>=WM_NCMOUSEMOVE && u_msg<=WM_NCXBUTTONDBLCLK)
{
// NC message coordinates are in screen coordinates.
POINT temp = mouse_pos.ToPOINT();
::MapWindowPoints(HWND_DESKTOP, GetParent(), &temp, 1);
mouse_pos.SetPoint(temp.x, temp.y);
}
if(u_msg!=WM_MOUSEMOVE || last_mouse_pos_!=mouse_pos)
{
last_mouse_pos_ = mouse_pos;
HideKeyboardTooltip();
UpdateTooltip(mouse_pos);
}
// Forward the message onto the tooltip.
MSG msg;
msg.hwnd = GetParent();
msg.message = u_msg;
msg.wParam = w_param;
msg.lParam = l_param;
SendMessage(tooltip_hwnd_, TTM_RELAYEVENT, 0, (LPARAM)&msg);
}
vec3 Camera::pickAgainstPlane(float x, float y, vec4 plane)
{
float nxPos = x / 1280.0f; //replace these with your screen width and height
float nyPos = y / 720.0f;
float sxPos = nxPos - 0.5f;
float syPos = nyPos - 0.5f;
float fxPos = sxPos * 2;
float fyPos = syPos * -2;
mat4 inv_viewproj = glm::inverse(view_proj); //view_proj is the memeber variable
vec4 mouse_pos(fxPos, fyPos, 1, 1);
vec4 world_pos = inv_viewproj * mouse_pos;
world_pos /= world_pos.w;
vec3 cam_pos = world[3].xyz(); //world is the member variable
vec3 dir = world_pos.xyz() - cam_pos;
float t = -(glm::dot(cam_pos, plane.xyz()) + plane.w)
/ (glm::dot(dir, plane.xyz()));
vec3 result = cam_pos + dir * t;
return result;
}
void draw_stuff(const controls& c, float density)
{
float mx = c.m_mouse_x - 500.0f;
float my = 500.0f - c.m_mouse_y;
vec3 mouse_pos(mx, my, 0);
if (c.m_mouse_right)
{
// Re-compute light direction.
s_light_direction = mouse_pos - s_light_arrow_spot;
s_light_direction.normalize();
// Direction perpendicular to the light.
s_light_right = vec3(s_light_direction.y, -s_light_direction.x, 0);
// Draw a white line to the mouse, so the user can see
// what they're orbiting around.
glColor3f(1, 1, 1);
draw_segment(s_light_arrow_spot, mouse_pos);
}
if (c.m_mouse_left_click)
{
// Add or delete an occluder.
// If we're on an occluder, then delete it.
bool deleted = false;
for (int i = 0; i < s_occluders.size(); i++)
{
if (s_occluders[i].hit(mouse_pos))
{
// Remove this guy.
s_occluders[i] = s_occluders.back();
s_occluders.resize(s_occluders.size() - 1);
deleted = true;
break;
}
}
if (!deleted)
{
// If we didn't delete, then the user want to
// add an occluder.
s_occluders.push_back(occluder(mouse_pos, 20));
}
}
draw_light_arrow();
draw_light_rays(density);
draw_occluders();
// Draw a line at the "near clip plane".
glColor3f(0, 0, 1);
draw_segment(vec3(-1000, s_viewer_y, 0), vec3(1000, s_viewer_y, 0));
draw_frustum();
}
void WindowProfiler::motion(int x, int y)
{
WindowProfiler::Window &window = m_window;
if (!window.m_mouseButtonFlags && mouse_pos(x,y)) return;
window.m_mouseCurrent[0] = x;
window.m_mouseCurrent[1] = y;
}
void NACLWindow::process_mouse_event( const pp::MouseInputEvent& ev )
{
if( ev.GetType() != PP_INPUTEVENT_TYPE_MOUSELEAVE)
{
int32 xPos = ev.GetPosition().x();
int32 yPos = ev.GetPosition().y();
Vector2 mouse_pos((float)xPos, (float)yPos);
m_mouse.pos = mouse_pos;
m_mouse.pos_pixels = Vector2(float(xPos), float(yPos));
}
else
{
m_mouse.buttons[0] = false;
m_mouse.buttons[1] = false;
m_mouse.buttons[2] = false;
}
uint8 button_idx = 0;
uint8 button_code = 0;
switch(ev.GetButton())
{
case PP_INPUTEVENT_MOUSEBUTTON_LEFT:
button_idx = 0;
button_code = 1;
break;
case PP_INPUTEVENT_MOUSEBUTTON_RIGHT:
button_idx = 1;
button_code = 2;
break;
case PP_INPUTEVENT_MOUSEBUTTON_MIDDLE:
button_idx = 1;
button_code = 4;
break;
}
if(ev.GetType() == PP_INPUTEVENT_TYPE_MOUSEMOVE)
{
listeners().broadcast(WindowEvent::MouseMove(m_mouse.pos));
}
else if(ev.GetType() == PP_INPUTEVENT_TYPE_MOUSEDOWN)
{
m_keyboard.keys[button_code] = true;
m_mouse.buttons[button_idx] = true;
listeners().broadcast(WindowEvent::MouseDown(m_mouse.pos, button_idx, false));
}
else if(ev.GetType() == PP_INPUTEVENT_TYPE_MOUSEUP)
{
m_keyboard.keys[button_code] = false;
m_mouse.buttons[button_idx] = false;
listeners().broadcast(WindowEvent::MouseUp(m_mouse.pos, button_idx));
}
}
void redraw (int w, int h, int mx, int my)
{
vapi_clear ();
rulers (w, h);
instructions (w, h);
mouse_pos (w, h, mx, my);
term_size (w, h);
vapi_moveto (1, 1);
vapi_refresh ();
}
void SliderViewImpl::on_pointer_move(PointerEvent &e)
{
if (_state_disabled)
return;
if (mouse_down_mode != mouse_down_thumb_drag)
{
return;
}
Pointf mouse_pos(e.pos(track.get()));
Rectf track_geometry(track->geometry().content_box());
int last_position = _position;
if (mouse_pos.x < -100 || mouse_pos.x > track_geometry.get_width() + 100 || mouse_pos.y < -100 || mouse_pos.y > track_geometry.get_height() + 100)
{
_position = thumb_move_start_position;
}
else
{
if (slider->horizontal())
{
int delta = (mouse_pos.x - mouse_drag_start_pos.x);
_position = thumb_move_start_position + (delta * (_max_position - _min_position)) / (track->geometry().content_box().get_width());
}
else
{
int delta = (mouse_pos.y - mouse_drag_start_pos.y);
_position = thumb_move_start_position + (delta * (_max_position - _min_position)) / (track->geometry().content_box().get_height());
}
}
if (_position > _max_position)
_position = _max_position;
if (_position < _min_position)
_position = _min_position;
if (_lock_to_ticks)
{
int remainder = (_position - _min_position) % _tick_count;
_position = _position - remainder;
}
if (last_position != _position)
{
if (_func_value_changed)
_func_value_changed();
slider->set_needs_layout();
}
}
void Desktop::ResendMouseMoveEvent() {
sf::Event event;
event.type = sf::Event::MouseMoved;
event.mouseMove.x = m_last_mouse_pos.x;
event.mouseMove.y = m_last_mouse_pos.y;
sf::Vector2f mouse_pos( static_cast<float>( m_last_mouse_pos.x ), static_cast<float>( m_last_mouse_pos.y ) );
for( std::size_t index = 0; index < m_children.size(); ++index ) {
if( m_children[index]->GetAllocation().contains( mouse_pos ) ) {
m_children[index]->HandleEvent( event );
break;
}
}
}
void OnMouseDown(sht::MouseButton button, int modifiers) final
{
if (object_manager_->editor_mode() && button == sht::MouseButton::kLeft)
{
vec2 mouse_pos(mouse_.x(), mouse_.y());
vec3 ray;
sht::math::ScreenToRay(mouse_pos, renderer_->viewport(),
renderer_->projection_matrix(), renderer_->view_matrix(), ray);
vec4 plane(0.0f, 1.0f, 0.0f, 0.0f);
vec3 intersection;
if (sht::math::RayPlaneIntersection(*camera_manager_->position(), ray, plane, intersection))
{
old_intersection_ = intersection;
}
}
}
// draw information about the shapes
void Controller::display_info()
{
// write coordinates on canvas (if on canvas)
if (_mouse_pos.x > BAD)
{
std::stringstream msstr;
msstr << _tile << std::endl << "(" << _mouse_pos.x << "," << _mouse_pos.y << ")" << std::endl <<
(_mouse_pos.x / TILE_SIZE) + (_mouse_pos.y / TILE_SIZE) * MAP_SIZE_W;
sf::Text mouse_pos(msstr.str(), _font);
mouse_pos.setColor(sf::Color::Blue);
mouse_pos.setPosition(WINDOW_WIDTH - 200, WINDOW_HEIGHT - 130);
// draw
_window.draw(mouse_pos);
}
}
/*! Processes input for the widget.
* Default processing includes mouse-over highlighting
*
* @param pInput Pointer to current input object
* @returns ICRESULT Success/failure of widget input processing
**/
ICRESULT icWidget::ProcessInput(icInput* pInput)
{
if (!pInput)
return IC_FAIL_GEN;
short x,y;
pInput->GetPos(&x,&y);
icVector2 mouse_pos((icReal)x,(icReal)y);
// update the input state
ic2DAABB box;
box.extents.x = m_v2Size.x/2.0f;
box.extents.y = m_v2Size.y/2.0f;
box.pos = m_v2Pos;
m_bMouseOver = ic2DPointAABB(mouse_pos,box);
if (m_bHighlightEnabled && !Sticky)
SetHighlight(m_bMouseOver);
return IC_OK;
}// END FUNCTION ProcessInput( icInput* pInput )
void EditorFileList::MouseMove(const IPoint &mouse_pos_)
{
int x = textXLeft;
int y = textYUp;
int dx = textDx;
int dy = textDy;
IPoint mouse_pos(mouse_pos_.x + _offsetColumn*dx, mouse_pos_.y);
Render::FreeType::BindFont("debug");
for (size_t i = 0; i < _names.size(); i++)
{
if (mouse_pos.x >= x && mouse_pos.x < x+Render::getStringWidth(_names[i]) &&
mouse_pos.y >= y && mouse_pos.y < y+Render::getFontHeight())
{
_underMouseName = static_cast<int>(i);
}
y -= dy;
if (y < textYDown)
{
y = textYUp;
x += dx;
}
}
}
void mouseevent::mouseMoveEvent(QMouseEvent *ev)
{
this->x = ev->x();
this->y = ev->y();
emit mouse_pos();
}
// Handling mouse events
// ^^^^^^^^^^^^^^^^^^^^^
//
// processMouseEvent() is sort of the main function of a Tool, because
// mouse interactions are the point of Tools.
//
// We use the utility function rviz::getPointOnPlaneFromWindowXY() to
// see where on the ground plane the user's mouse is pointing, then
// move the moving flag to that point and update the VectorProperty.
//
// If this mouse event was a left button press, we want to save the
// current flag location. Therefore we make a new flag at the same
// place and drop the pointer to the VectorProperty. Dropping the
// pointer means when the tool is deactivated the VectorProperty won't
// be deleted, which is what we want.
int FlagTool3D::processMouseEvent( rviz::ViewportMouseEvent& event )
{
if( !moving_flag_node_ )
{
return Render;
}
Ogre::Vector3 intersection,intersection1;
Ogre::Plane ground_plane( Ogre::Vector3::UNIT_Z, 0.0f );
if( rviz::getPointOnPlaneFromWindowXY( event.viewport,
ground_plane,
event.x, event.y, intersection ))
{
//moving_flag_node_->setVisible( true );
moving_flag_node_->setPosition( intersection );
current_flag_property_->setVector( intersection );
if( event.leftDown() )
{
std::cout << "Computing projection for " << pcd.size() << " points.\n";
for( size_t i = 0; i < pcd.size(); i++ ) {
Ogre::Vector3 temp3D(pcd.points[i].x,pcd.points[i].y,pcd.points[i].z);
Ogre::Vector2 temp2D = rviz::project3DPointToViewportXY(event.viewport,temp3D);
//std::cout << "\t3D - x: " << temp3D.x << " y: " << temp3D.y << " z: " << temp3D.z << "\t";
//std::cout << "2D - x: " << temp2D.x << " y: " << temp2D.y << "\n";
correspondences.push_back(std::make_pair(temp3D,temp2D));
}
Ogre::Vector2 mouse_pos(event.x,event.y),closest;
std::cout << "Mouse position - x: " << event.x << " y: " << event.y << "\n";
std::cout << "Computing distances for " << correspondences.size() << " points:\n";
double min_dist = 1000000;
for(std::vector<std::pair<Ogre::Vector3,Ogre::Vector2> >::iterator it=correspondences.begin(); it != correspondences.end(); ++it){
std::pair<Ogre::Vector3,Ogre::Vector2> pair = *it;
double dist = FlagTool3D::computeDistance(mouse_pos,pair.second);
//std::cout << "\t2D Point - x: " << pair.second.x << " y: " << pair.second.y << "\tdistance: " << dist << "\n";
if(dist < min_dist) {
min_dist = dist;
intersection1 = pair.first;
closest = pair.second;
}
}
std::cout << "Closest point - x: " << closest.x << " y: " << closest.y << "\n";
std::cout << "Distance: " << min_dist << "\n";
std::cout << "3D point - x: " << intersection1.x << " y: " << intersection1.y << " z: " << intersection1.z << "\n";
moving_flag_node_->setVisible( true );
makeFlag( intersection1 );
//std::cout << "Ogre 3D point - x: " << intersection.x << " y: " << intersection.y << " z: " << intersection.z << "\n";
//std::cout << "--------------------------------------------------------------------------------------------------\n";
//Adding flag pose to the list
geometry_msgs::Pose wp_pose;
wp_pose.position.x = intersection1.x;
wp_pose.position.y = intersection1.y;
wp_pose.position.z = intersection1.z;
wplist.poses.push_back(wp_pose);
current_flag_property_ = NULL; // Drop the reference so that deactivate() won't remove it.
return Render | Finished;
}
if( event.rightDown() ){
//Publishing the flag pose
pub.publish(wplist);
return Render | Finished;
}
}
else
{
moving_flag_node_->setVisible( false ); // If the mouse is not pointing at the ground plane, don't show the flag.
}
correspondences.clear();
return Render;
}
int dgreed_main(int argc, const char** argv) {
log_init("pview.log", LOG_LEVEL_INFO);
video_init(800, 600, "PView");
rand_init(666);
GuiDesc style = greed_gui_style(false);
gui_init(&style);
particles_init("greed_assets/", 5);
TexHandle empty = tex_load("greed_assets/empty.png");
if(psystem_descs_count < 1)
LOG_ERROR("No particle systems described!");
int active_backg = 0;
int active_desc = 0;
const char* active_desc_name = psystem_descs[active_desc].name;
RectF gui_area = rectf(0.0f, 0.0f, 520.0f, 80.0f);
RectF gui_area2 = rectf(0.0f, 500.0f, 280.0f, 600.0f);
Vector2 button_prev_pos = vec2(10.0f, 10.0f);
Vector2 button_next_pos = vec2(280.0f, 10.0f);
Vector2 button_backg_pos = vec2(10.0f, 550.0f);
Vector2 label_name_pos = vec2(20.0f, 60.0f);
char label_text[256];
while(system_update()) {
RectF src = rectf_null();
RectF dest = {0.0f, 0.0f, EDITOR_WIDTH, EDITOR_HEIGHT};
Color c = backgrounds[active_backg % ARRAY_SIZE(backgrounds)];
video_draw_rect(empty, 0, &src, &dest, c);
if(mouse_down(MBTN_LEFT)) {
uint x, y;
mouse_pos(&x, &y);
Vector2 pos = vec2((float)x, (float)y);
if(!rectf_contains_point(&gui_area, &pos))
if(!rectf_contains_point(&gui_area2, &pos))
particles_spawn(active_desc_name, &pos, 0.0f);
}
particles_update(time_ms() / 1000.0f);
sprintf(label_text, "Current psystem: %s", active_desc_name);
gui_label(&label_name_pos, label_text);
if(gui_button(&button_prev_pos, "Previuos"))
active_desc = MAX(0, active_desc-1);
if(gui_button(&button_next_pos, "Next"))
active_desc = MIN(psystem_descs_count-1, active_desc+1);
if(gui_button(&button_backg_pos, "Background color"))
active_backg++;
active_desc_name = psystem_descs[active_desc].name;
particles_draw();
draw_grid(0, 12.0f);
video_present();
}
tex_free(empty);
particles_close();
gui_close();
greed_gui_free();
video_close();
log_close();
return 0;
}
void View2D::OnMouseEvent(wxMouseEvent& event)
{
static vec2 last_pos;
vec2 full_size = Get2DPoint(CPU_VD::GetFullSize());
this->SetFocus();
float hscale = 1.0f/(height+0.0001f);
vec2 mouse_pos(event.GetX(),event.GetY());
vec2 real_pos = (mouse_pos)*(hscale/scale)+center;
static vec2 real_pos_old = real_pos;
mouse_left_is_down=event.LeftIsDown();
if(!(mouse_pos==last_pos))
{
//wxLogStatus(MyApp::frame, _T("%g"), (event.GetX()/scale+center)*(256*128)+data_stat.MinValue);
if(event.MiddleIsDown() || event.RightIsDown() || (event.LeftIsDown() && cur_action == V2D_ACTION_TRANSLATE))
{
center -= ((mouse_pos-last_pos))*mirror*(hscale/scale);
//center -= real_pos-real_pos_old;
MyRefresh();
}
if(event.LeftIsDown())
{
if(cur_action == V2D_ACTION_ZOOM)
{
scale*=((mouse_pos.y>last_pos.y)?1.1f:0.9f);
center = real_pos-(last_pos)*(hscale/scale);
MyRefresh();
}
if(cur_action == V2D_ACTION_BC)
{
float dw = (event.GetX()-last_pos.x)*0.0001;
float dl = (event.GetY()-last_pos.y)*0.0001;
//vec2 oww = CT::iso->GetWindow();
bc += vec2(dl-dw,dl+dw);
CT::need_rerender2d=1;
}
if(cur_action == V2D_ACTION_ARROW)
{
if(selected_obj==V2D_SELECTION_OBJECT_CENTER)
{
CT::need_rerender2d=1;
vec3 center1 = CT::GetCenter();
if(selected_part==V2D_SELECTION_PART_X || selected_part==V2D_SELECTION_PART_CENTER)
{
center1.SetByID(axis_y,clamp(0.0f,1.0f,real_pos.y/full_size.y));
MyApp::frame->v2d[axis_y]->need_Update1=1;
}
if(selected_part==V2D_SELECTION_PART_Y || selected_part==V2D_SELECTION_PART_CENTER)
{
center1.SetByID(axis_x,clamp(0.0f,1.0f,real_pos.x/full_size.x));
MyApp::frame->v2d[axis_x]->need_Update1=1;
}
CT::SetCenter(center1);
}
if(selected_obj==V2D_SELECTION_OBJECT_BB)
{
vec2 b1 = Get2DBoxMin(), b2 = Get2DBoxMax();
if(selected_part==V2D_SELECTION_PART_POINT)
{
if(selected_id==0)
b1 = real_pos;
else if(selected_id==1)
{b1.y = real_pos.y;b2.x = real_pos.x;}
else if(selected_id==2)
{b2.y = real_pos.y;b1.x = real_pos.x;}
else if(selected_id==3)
b2 = real_pos;
}
else
if(selected_part==V2D_SELECTION_PART_EDGE)
{
if(selected_id==0)
b1.y = real_pos.y;
else if(selected_id==1)
b2.y = real_pos.y;
else if(selected_id==2)
b1.x = real_pos.x;
else if(selected_id==3)
b2.x = real_pos.x;
}
else
if(selected_part==V2D_SELECTION_PART_FACE)
{
b1 += real_pos-real_pos_old;
b2 += real_pos-real_pos_old;
}
if(b2.x < b1.x) b2.x = b1.x = (b2.x + b1.x)*0.5f;
if(b2.y < b1.y) b2.y = b1.y = (b2.y + b1.y)*0.5f;
CT::iso->SetBoundingBox(Get3DPoint(b1,CT::iso->GetBoundingBox(0).GetByID(axis)),Get3DPoint(b2,CT::iso->GetBoundingBox(1).GetByID(axis)));
MyRefresh();
}
}
}
}
/////////////// hover
int old_s = sel_obj + sel_part*100 + sel_id*10;
sel_obj=-1;
if(cur_action == V2D_ACTION_ARROW)
{
int bb_frame = 4;
vec2 cc_screen = ((Get2DPoint(CT::GetCenter())*full_size-center))*scale/hscale;
if(event.GetX()>cc_screen.x-bb_frame && event.GetX()<cc_screen.x+bb_frame)
{
sel_obj = V2D_SELECTION_OBJECT_CENTER;
sel_part = V2D_SELECTION_PART_Y;
}
if(event.GetY()>cc_screen.y-bb_frame && event.GetY()<cc_screen.y+bb_frame)
{
sel_part = (sel_obj==-1)?V2D_SELECTION_PART_X : V2D_SELECTION_PART_CENTER;
sel_obj = V2D_SELECTION_OBJECT_CENTER;
}
if(sel_obj==-1)
{
vec2 b1 = Get2DBoxMin(), b2 = Get2DBoxMax();
vec2 b1_screen = ((b1-center))*scale/hscale, b2_screen = ((b2-center))*scale/hscale;
vec2 b1_screen1 = vec2::Min(b1_screen,b2_screen),b2_screen1 = vec2::Max(b1_screen,b2_screen);
if(AinsideBC(mouse_pos , b1_screen1-vec2(bb_frame), b2_screen1+vec2(bb_frame)))
{
sel_obj = V2D_SELECTION_OBJECT_BB;
if(AnearB(mouse_pos,b1_screen,bb_frame))
{
sel_part = V2D_SELECTION_PART_POINT;
sel_id = 0;
}else
if(AnearB(mouse_pos,vec2(b2_screen.x,b1_screen.y),bb_frame))
{
sel_part = V2D_SELECTION_PART_POINT;
sel_id = 1;
}else
if(AnearB(mouse_pos,vec2(b1_screen.x,b2_screen.y),bb_frame))
{
sel_part = V2D_SELECTION_PART_POINT;
sel_id = 2;
}else
if(AnearB(mouse_pos,b2_screen,bb_frame))
{
sel_part = V2D_SELECTION_PART_POINT;
sel_id = 3;
}else
if(event.GetY()<b1_screen.y+bb_frame && event.GetY()>b1_screen.y-bb_frame)
{
sel_part = V2D_SELECTION_PART_EDGE;
sel_id = 0;
}else
if(event.GetY()>b2_screen.y-bb_frame && event.GetY()<b2_screen.y+bb_frame)
{
sel_part = V2D_SELECTION_PART_EDGE;
sel_id = 1;
}else
if(event.GetX()<b1_screen.x+bb_frame && event.GetX()>b1_screen.x-bb_frame)
{
sel_part = V2D_SELECTION_PART_EDGE;
sel_id = 2;
}else
if(event.GetX()>b2_screen.x-bb_frame && event.GetX()<b2_screen.x+bb_frame)
{
sel_part = V2D_SELECTION_PART_EDGE;
sel_id = 3;
}else
sel_part = V2D_SELECTION_PART_FACE;
}
}
}
if(old_s != sel_obj + sel_part*100 + sel_id*10)
MyRefresh();
if(event.IsButton())
{
if(event.LeftDown())
{
selected_obj = sel_obj;
selected_id = sel_id;
selected_part = sel_part;
}else selected_obj=-1;
MyRefresh();
}
if(event.m_wheelRotation)
{
scale*=(event.m_wheelRotation>0?1.1f:0.9f);
center = (real_pos-(last_pos)*(hscale/scale))*mirror;
MyRefresh();
}
last_pos=mouse_pos;
real_pos_old = real_pos;
UpdateCursor();
}
bool DeckBuilder::OnEvent(const irr::SEvent& event) {
switch(event.EventType) {
case irr::EET_GUI_EVENT: {
s32 id = event.GUIEvent.Caller->getID();
if(mainGame->wCategories->isVisible() && id != BUTTON_CATEGORY_OK)
break;
if(mainGame->wQuery->isVisible() && id != BUTTON_YES && id != BUTTON_NO)
break;
switch(event.GUIEvent.EventType) {
case irr::gui::EGET_BUTTON_CLICKED: {
switch(id) {
case BUTTON_CLEAR_DECK: {
mainGame->gMutex.Lock();
mainGame->SetStaticText(mainGame->stQMessage, 310, mainGame->textFont, (wchar_t*)dataManager.GetSysString(1339));
mainGame->PopupElement(mainGame->wQuery);
mainGame->gMutex.Unlock();
is_clearing = true;
break;
}
case BUTTON_SORT_DECK: {
std::sort(deckManager.current_deck.main.begin(), deckManager.current_deck.main.end(), ClientCard::deck_sort_lv);
std::sort(deckManager.current_deck.extra.begin(), deckManager.current_deck.extra.end(), ClientCard::deck_sort_lv);
std::sort(deckManager.current_deck.side.begin(), deckManager.current_deck.side.end(), ClientCard::deck_sort_lv);
break;
}
case BUTTON_SHUFFLE_DECK: {
std::random_shuffle(deckManager.current_deck.main.begin(), deckManager.current_deck.main.end());
break;
}
case BUTTON_SAVE_DECK: {
if(deckManager.SaveDeck(deckManager.current_deck, mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()))) {
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
case BUTTON_SAVE_DECK_AS: {
const wchar_t* dname = mainGame->ebDeckname->getText();
if(*dname == 0)
break;
int sel = -1;
for(size_t i = 0; i < mainGame->cbDBDecks->getItemCount(); ++i) {
if(!wcscmp(dname, mainGame->cbDBDecks->getItem(i))) {
sel = i;
break;
}
}
if(sel >= 0)
mainGame->cbDBDecks->setSelected(sel);
else {
mainGame->cbDBDecks->addItem(dname);
mainGame->cbDBDecks->setSelected(mainGame->cbDBDecks->getItemCount() - 1);
}
if(deckManager.SaveDeck(deckManager.current_deck, dname)) {
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
case BUTTON_DELETE_DECK: {
int sel = mainGame->cbDBDecks->getSelected();
if(sel == -1)
break;
mainGame->gMutex.Lock();
wchar_t textBuffer[256];
myswprintf(textBuffer, L"%ls\n%ls", mainGame->cbDBDecks->getItem(sel), dataManager.GetSysString(1337));
mainGame->SetStaticText(mainGame->stQMessage, 310, mainGame->textFont, (wchar_t*)textBuffer);
mainGame->PopupElement(mainGame->wQuery);
mainGame->gMutex.Unlock();
is_deleting = true;
break;
}
case BUTTON_LEAVE_GAME: {
mainGame->is_building = false;
mainGame->wDeckEdit->setVisible(false);
mainGame->wCategories->setVisible(false);
mainGame->wFilter->setVisible(false);
mainGame->wSort->setVisible(false);
mainGame->wCardImg->setVisible(false);
mainGame->wInfos->setVisible(false);
mainGame->btnLeaveGame->setVisible(false);
mainGame->PopupElement(mainGame->wMainMenu);
mainGame->device->setEventReceiver(&mainGame->menuHandler);
mainGame->wACMessage->setVisible(false);
imageManager.ClearTexture();
mainGame->scrFilter->setVisible(false);
if(mainGame->cbDBDecks->getSelected() != -1) {
BufferIO::CopyWStr(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()), mainGame->gameConf.lastdeck, 64);
}
if(exit_on_return)
mainGame->device->closeDevice();
break;
}
case BUTTON_EFFECT_FILTER: {
mainGame->PopupElement(mainGame->wCategories);
break;
}
case BUTTON_START_FILTER: {
filter_type = mainGame->cbCardType->getSelected();
filter_type2 = mainGame->cbCardType2->getItemData(mainGame->cbCardType2->getSelected());
filter_lm = mainGame->cbLimit->getSelected();
if(filter_type == 1) {
filter_attrib = mainGame->cbAttribute->getItemData(mainGame->cbAttribute->getSelected());
filter_race = mainGame->cbRace->getItemData(mainGame->cbRace->getSelected());
filter_atk = parse_filter(mainGame->ebAttack->getText(), &filter_atktype);
filter_def = parse_filter(mainGame->ebDefense->getText(), &filter_deftype);
filter_lv = parse_filter(mainGame->ebStar->getText(), &filter_lvtype);
filter_scl = parse_filter(mainGame->ebScale->getText(), &filter_scltype);
}
FilterCards();
if(!mainGame->gameConf.separate_clear_button)
ClearFilter();
break;
}
case BUTTON_CLEAR_FILTER: {
ClearSearch();
break;
}
case BUTTON_CATEGORY_OK: {
filter_effect = 0;
long long filter = 0x1;
for(int i = 0; i < 32; ++i, filter <<= 1)
if(mainGame->chkCategory[i]->isChecked())
filter_effect |= filter;
mainGame->HideElement(mainGame->wCategories);
break;
}
case BUTTON_SIDE_OK: {
if(deckManager.current_deck.main.size() != pre_mainc || deckManager.current_deck.extra.size() != pre_extrac
|| deckManager.current_deck.side.size() != pre_sidec) {
mainGame->env->addMessageBox(L"", dataManager.GetSysString(1410));
break;
}
char deckbuf[1024];
char* pdeck = deckbuf;
BufferIO::WriteInt32(pdeck, deckManager.current_deck.main.size() + deckManager.current_deck.extra.size());
BufferIO::WriteInt32(pdeck, deckManager.current_deck.side.size());
for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.main[i]->first);
for(size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.extra[i]->first);
for(size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.side[i]->first);
DuelClient::SendBufferToServer(CTOS_UPDATE_DECK, deckbuf, pdeck - deckbuf);
break;
}
case BUTTON_YES: {
mainGame->HideElement(mainGame->wQuery);
if(!mainGame->is_building || mainGame->is_siding)
break;
if(is_clearing) {
deckManager.current_deck.main.clear();
deckManager.current_deck.extra.clear();
deckManager.current_deck.side.clear();
} else if(is_deleting) {
int sel = mainGame->cbDBDecks->getSelected();
if (deckManager.DeleteDeck(deckManager.current_deck, mainGame->cbDBDecks->getItem(sel))) {
mainGame->cbDBDecks->removeItem(sel);
int count = mainGame->cbDBDecks->getItemCount();
if (sel >= count)
sel = count - 1;
mainGame->cbDBDecks->setSelected(sel);
if (sel != -1)
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(sel));
mainGame->stACMessage->setText(dataManager.GetSysString(1338));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
}
is_clearing = false;
is_deleting = false;
break;
}
case BUTTON_NO: {
mainGame->HideElement(mainGame->wQuery);
is_deleting = false;
is_clearing = false;
break;
}
}
break;
}
case irr::gui::EGET_SCROLL_BAR_CHANGED: {
switch(id) {
case SCROLL_CARDTEXT: {
u32 pos = mainGame->scrCardText->getPos();
mainGame->SetStaticText(mainGame->stText, mainGame->stText->getRelativePosition().getWidth()-25, mainGame->textFont, mainGame->showingtext, pos);
break;
}
break;
}
}
case irr::gui::EGET_EDITBOX_ENTER: {
switch(id) {
case EDITBOX_KEYWORD: {
irr::SEvent me;
me.EventType = irr::EET_GUI_EVENT;
me.GUIEvent.EventType = irr::gui::EGET_BUTTON_CLICKED;
me.GUIEvent.Caller = mainGame->btnStartFilter;
me.GUIEvent.Element = mainGame->btnStartFilter;
mainGame->device->postEventFromUser(me);
break;
}
}
break;
}
case irr::gui::EGET_COMBO_BOX_CHANGED: {
switch(id) {
case COMBOBOX_DBLFLIST: {
filterList = deckManager._lfList[mainGame->cbDBLFList->getSelected()].content;
break;
}
case COMBOBOX_DBDECKS: {
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
break;
}
case COMBOBOX_MAINTYPE: {
mainGame->cbCardType2->setSelected(0);
mainGame->cbAttribute->setSelected(0);
mainGame->cbRace->setSelected(0);
mainGame->ebAttack->setText(L"");
mainGame->ebDefense->setText(L"");
mainGame->ebStar->setText(L"");
mainGame->ebScale->setText(L"");
switch(mainGame->cbCardType->getSelected()) {
case 0: {
mainGame->cbCardType2->setEnabled(false);
mainGame->cbCardType2->setSelected(0);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
break;
}
case 1: {
wchar_t normaltuner[32];
wchar_t normalpen[32];
wchar_t syntuner[32];
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(true);
mainGame->cbAttribute->setEnabled(true);
mainGame->ebAttack->setEnabled(true);
mainGame->ebDefense->setEnabled(true);
mainGame->ebStar->setEnabled(true);
mainGame->ebScale->setEnabled(true);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_MONSTER + TYPE_NORMAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1055), TYPE_MONSTER + TYPE_EFFECT);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1056), TYPE_MONSTER + TYPE_FUSION);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1057), TYPE_MONSTER + TYPE_RITUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1063), TYPE_MONSTER + TYPE_SYNCHRO);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1073), TYPE_MONSTER + TYPE_XYZ);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1074), TYPE_MONSTER + TYPE_PENDULUM);
myswprintf(normaltuner, L"%ls|%ls", dataManager.GetSysString(1054), dataManager.GetSysString(1062));
mainGame->cbCardType2->addItem(normaltuner, TYPE_MONSTER + TYPE_NORMAL + TYPE_TUNER);
myswprintf(normalpen, L"%ls|%ls", dataManager.GetSysString(1054), dataManager.GetSysString(1074));
mainGame->cbCardType2->addItem(normalpen, TYPE_MONSTER + TYPE_NORMAL + TYPE_PENDULUM);
myswprintf(syntuner, L"%ls|%ls", dataManager.GetSysString(1063), dataManager.GetSysString(1062));
mainGame->cbCardType2->addItem(syntuner, TYPE_MONSTER + TYPE_SYNCHRO + TYPE_TUNER);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1062), TYPE_MONSTER + TYPE_TUNER);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1061), TYPE_MONSTER + TYPE_DUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1060), TYPE_MONSTER + TYPE_UNION);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1059), TYPE_MONSTER + TYPE_SPIRIT);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1071), TYPE_MONSTER + TYPE_FLIP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1072), TYPE_MONSTER + TYPE_TOON);
break;
}
case 2: {
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_SPELL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1066), TYPE_SPELL + TYPE_QUICKPLAY);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1067), TYPE_SPELL + TYPE_CONTINUOUS);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1057), TYPE_SPELL + TYPE_RITUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1068), TYPE_SPELL + TYPE_EQUIP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1069), TYPE_SPELL + TYPE_FIELD);
break;
}
case 3: {
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_TRAP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1067), TYPE_TRAP + TYPE_CONTINUOUS);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1070), TYPE_TRAP + TYPE_COUNTER);
break;
}
}
break;
}
case COMBOBOX_SORTTYPE: {
SortList();
mainGame->env->setFocus(0);
break;
}
}
}
default:
break;
}
break;
}
case irr::EET_MOUSE_INPUT_EVENT: {
switch(event.MouseInput.Event) {
case irr::EMIE_LMOUSE_PRESSED_DOWN: {
irr::core::position2di mouse_pos(event.MouseInput.X, event.MouseInput.Y);
irr::gui::IGUIElement* root = mainGame->env->getRootGUIElement();
if(root->getElementFromPoint(mouse_pos) != root)
break;
if(mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
click_pos = hovered_pos;
dragx = event.MouseInput.X;
dragy = event.MouseInput.Y;
draging_pointer = dataManager.GetCodePointer(hovered_code);
if(draging_pointer == dataManager._datas.end())
break;
unsigned int limitcode = draging_pointer->second.alias ? draging_pointer->second.alias : draging_pointer->first;
if(hovered_pos == 4) {
int limit = 3;
if(filterList->count(limitcode))
limit = (*filterList)[limitcode];
for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
if(deckManager.current_deck.main[i]->first == limitcode
|| deckManager.current_deck.main[i]->second.alias == limitcode)
limit--;
for(size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
if(deckManager.current_deck.extra[i]->first == limitcode
|| deckManager.current_deck.extra[i]->second.alias == limitcode)
limit--;
for(size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
if(deckManager.current_deck.side[i]->first == limitcode
|| deckManager.current_deck.side[i]->second.alias == limitcode)
limit--;
if(limit <= 0)
break;
}
if(hovered_pos == 1)
deckManager.current_deck.main.erase(deckManager.current_deck.main.begin() + hovered_seq);
else if(hovered_pos == 2)
deckManager.current_deck.extra.erase(deckManager.current_deck.extra.begin() + hovered_seq);
else if(hovered_pos == 3)
deckManager.current_deck.side.erase(deckManager.current_deck.side.begin() + hovered_seq);
is_draging = true;
break;
}
case irr::EMIE_LMOUSE_LEFT_UP: {
if(!is_draging)
break;
if(!mainGame->is_siding) {
if((hovered_pos == 1 && (draging_pointer->second.type & 0x802040)) || (hovered_pos == 2 && !(draging_pointer->second.type & 0x802040)))
hovered_pos = 0;
if((hovered_pos == 1 || (hovered_pos == 0 && click_pos == 1)) && deckManager.current_deck.main.size() < 60) {
if(hovered_seq == -1)
deckManager.current_deck.main.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.main.size() && hovered_pos)
deckManager.current_deck.main.insert(deckManager.current_deck.main.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.main.push_back(draging_pointer);
is_draging = false;
} else if((hovered_pos == 2 || (hovered_pos == 0 && click_pos == 2)) && deckManager.current_deck.extra.size() < 15) {
if(hovered_seq == -1)
deckManager.current_deck.extra.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.extra.size() && hovered_pos)
deckManager.current_deck.extra.insert(deckManager.current_deck.extra.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.extra.push_back(draging_pointer);
is_draging = false;
} else if((hovered_pos == 3 || (hovered_pos == 0 && click_pos == 3)) && deckManager.current_deck.side.size() < 15) {
if(hovered_seq == -1)
deckManager.current_deck.side.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.side.size() && hovered_pos)
deckManager.current_deck.side.insert(deckManager.current_deck.side.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
} else if (hovered_pos == 4)
is_draging = false;
} else {
if((hovered_pos == 1 && (draging_pointer->second.type & 0x802040)) || (hovered_pos == 2 && !(draging_pointer->second.type & 0x802040)) || hovered_pos == 4)
hovered_pos = 0;
if((hovered_pos == 1 || (hovered_pos == 0 && click_pos == 1)) && deckManager.current_deck.main.size() < 65) {
if(hovered_seq == -1)
deckManager.current_deck.main.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.main.size() && hovered_pos)
deckManager.current_deck.main.insert(deckManager.current_deck.main.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.main.push_back(draging_pointer);
is_draging = false;
} else if((hovered_pos == 2 || (hovered_pos == 0 && click_pos == 2)) && deckManager.current_deck.extra.size() < 20) {
if(hovered_seq == -1)
deckManager.current_deck.extra.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.extra.size() && hovered_pos)
deckManager.current_deck.extra.insert(deckManager.current_deck.extra.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.extra.push_back(draging_pointer);
is_draging = false;
} else if((hovered_pos == 3 || (hovered_pos == 0 && click_pos == 3)) && deckManager.current_deck.side.size() < 20) {
if(hovered_seq == -1)
deckManager.current_deck.side.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.side.size() && hovered_pos)
deckManager.current_deck.side.insert(deckManager.current_deck.side.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
}
}
if(is_draging) {
if(click_pos == 1)
deckManager.current_deck.main.push_back(draging_pointer);
else if(click_pos == 2)
deckManager.current_deck.extra.push_back(draging_pointer);
else if(click_pos == 3)
deckManager.current_deck.side.push_back(draging_pointer);
}
is_draging = false;
break;
}
case irr::EMIE_RMOUSE_LEFT_UP: {
if(mainGame->is_siding) {
if(is_draging)
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
draging_pointer = dataManager.GetCodePointer(hovered_code);
if(draging_pointer == dataManager._datas.end())
break;
if(hovered_pos == 1) {
if(deckManager.current_deck.side.size() < 20) {
deckManager.current_deck.main.erase(deckManager.current_deck.main.begin() + hovered_seq);
deckManager.current_deck.side.push_back(draging_pointer);
}
} else if(hovered_pos == 2) {
if(deckManager.current_deck.side.size() < 20) {
deckManager.current_deck.extra.erase(deckManager.current_deck.extra.begin() + hovered_seq);
deckManager.current_deck.side.push_back(draging_pointer);
}
} else {
if((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 20) {
deckManager.current_deck.side.erase(deckManager.current_deck.side.begin() + hovered_seq);
deckManager.current_deck.extra.push_back(draging_pointer);
}
if(!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 64) {
deckManager.current_deck.side.erase(deckManager.current_deck.side.begin() + hovered_seq);
deckManager.current_deck.main.push_back(draging_pointer);
}
}
break;
}
if(mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
if(!is_draging) {
draging_pointer = dataManager.GetCodePointer(hovered_code);
if(draging_pointer == dataManager._datas.end())
break;
}
if(hovered_pos == 1) {
if(!is_draging)
deckManager.current_deck.main.erase(deckManager.current_deck.main.begin() + hovered_seq);
else if(deckManager.current_deck.side.size() < 15) {
deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
}
} else if(hovered_pos == 2) {
if(!is_draging)
deckManager.current_deck.extra.erase(deckManager.current_deck.extra.begin() + hovered_seq);
else if(deckManager.current_deck.side.size() < 15) {
deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
}
} else if(hovered_pos == 3) {
if(!is_draging)
deckManager.current_deck.side.erase(deckManager.current_deck.side.begin() + hovered_seq);
else {
if((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 15) {
deckManager.current_deck.extra.push_back(draging_pointer);
is_draging = false;
} else if(!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 60) {
deckManager.current_deck.main.push_back(draging_pointer);
is_draging = false;
}
}
} else {
if(is_draging) {
if(deckManager.current_deck.side.size() < 15) {
deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
}
} else {
unsigned int limitcode = draging_pointer->second.alias ? draging_pointer->second.alias : draging_pointer->first;
int limit = 3;
if(filterList->count(limitcode))
limit = (*filterList)[limitcode];
for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
if(deckManager.current_deck.main[i]->first == limitcode
|| deckManager.current_deck.main[i]->second.alias == limitcode)
limit--;
for(size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
if(deckManager.current_deck.extra[i]->first == limitcode
|| deckManager.current_deck.extra[i]->second.alias == limitcode)
limit--;
for(size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
if(deckManager.current_deck.side[i]->first == limitcode
|| deckManager.current_deck.side[i]->second.alias == limitcode)
limit--;
if(limit <= 0)
break;
if((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 15) {
deckManager.current_deck.extra.push_back(draging_pointer);
} else if(!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 60) {
deckManager.current_deck.main.push_back(draging_pointer);
} else if (deckManager.current_deck.side.size() < 15) {
deckManager.current_deck.side.push_back(draging_pointer);
}
}
}
break;
}
case irr::EMIE_MMOUSE_LEFT_UP: {
if (mainGame->is_siding)
break;
if (mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if (hovered_pos == 0 || hovered_seq == -1)
break;
if (is_draging)
break;
draging_pointer = dataManager.GetCodePointer(hovered_code);
unsigned int limitcode = draging_pointer->second.alias ? draging_pointer->second.alias : draging_pointer->first;
int limit = 3;
if (filterList->count(limitcode))
limit = (*filterList)[limitcode];
for (size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
if (deckManager.current_deck.main[i]->first == limitcode
|| deckManager.current_deck.main[i]->second.alias == limitcode)
limit--;
for (size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
if (deckManager.current_deck.extra[i]->first == limitcode
|| deckManager.current_deck.extra[i]->second.alias == limitcode)
limit--;
for (size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
if (deckManager.current_deck.side[i]->first == limitcode
|| deckManager.current_deck.side[i]->second.alias == limitcode)
limit--;
if (limit <= 0)
break;
if (hovered_pos == 1) {
if (deckManager.current_deck.main.size() < 60)
deckManager.current_deck.main.push_back(draging_pointer);
else if (deckManager.current_deck.side.size() < 15)
deckManager.current_deck.side.push_back(draging_pointer);
} else if (hovered_pos == 2) {
if (deckManager.current_deck.extra.size() < 15)
deckManager.current_deck.extra.push_back(draging_pointer);
else if (deckManager.current_deck.side.size() < 15)
deckManager.current_deck.side.push_back(draging_pointer);
} else if (hovered_pos == 3) {
if (deckManager.current_deck.side.size() < 15)
deckManager.current_deck.side.push_back(draging_pointer);
else {
if ((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 15)
deckManager.current_deck.extra.push_back(draging_pointer);
else if (!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 60)
deckManager.current_deck.main.push_back(draging_pointer);
}
} else {
if ((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 15)
deckManager.current_deck.extra.push_back(draging_pointer);
else if (!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 60)
deckManager.current_deck.main.push_back(draging_pointer);
else if (deckManager.current_deck.side.size() < 15)
deckManager.current_deck.side.push_back(draging_pointer);
}
break;
}
case irr::EMIE_MOUSE_MOVED: {
int x = event.MouseInput.X;
int y = event.MouseInput.Y;
irr::core::position2di mouse_pos(x, y);
irr::gui::IGUIElement* root = mainGame->env->getRootGUIElement();
if(root->getElementFromPoint(mouse_pos) != root)
break;
int pre_code = hovered_code;
if(x >= 314 && x <= 794 && y >= 164 && y <= 435) {
int lx = 10, px, py = (y - 164) / 68;
hovered_pos = 1;
if(deckManager.current_deck.main.size() > 40)
lx = (deckManager.current_deck.main.size() - 41) / 4 + 11;
if(x >= 750)
px = lx - 1;
else px = (x - 314) * (lx - 1) / 436;
if(py*lx + px >= (int)deckManager.current_deck.main.size()) {
hovered_seq = -1;
hovered_code = 0;
} else {
hovered_seq = py * lx + px;
hovered_code = deckManager.current_deck.main[hovered_seq]->first;
}
} else if(x >= 314 && x <= 794 && y >= 466 && y <= 530) {
int lx = deckManager.current_deck.extra.size();
hovered_pos = 2;
if(lx < 10)
lx = 10;
if(x >= 750)
hovered_seq = lx - 1;
else hovered_seq = (x - 314) * (lx - 1) / 436;
if(hovered_seq >= (int)deckManager.current_deck.extra.size()) {
hovered_seq = -1;
hovered_code = 0;
} else {
hovered_code = deckManager.current_deck.extra[hovered_seq]->first;
}
} else if (x >= 314 && x <= 794 && y >= 564 && y <= 628) {
int lx = deckManager.current_deck.side.size();
hovered_pos = 3;
if(lx < 10)
lx = 10;
if(x >= 750)
hovered_seq = lx - 1;
else hovered_seq = (x - 314) * (lx - 1) / 436;
if(hovered_seq >= (int)deckManager.current_deck.side.size()) {
hovered_seq = -1;
hovered_code = 0;
} else {
hovered_code = deckManager.current_deck.side[hovered_seq]->first;
}
} else if(x >= 810 && x <= 995 && y >= 165 && y <= 626) {
hovered_pos = 4;
hovered_seq = (y - 165) / 66;
if(mainGame->scrFilter->getPos() + hovered_seq >= (int)results.size()) {
hovered_seq = -1;
hovered_code = 0;
} else {
hovered_code = results[mainGame->scrFilter->getPos() + hovered_seq]->first;
}
} else {
hovered_pos = 0;
hovered_code = 0;
}
if(is_draging) {
dragx = x;
dragy = y;
}
if(!is_draging && pre_code != hovered_code) {
if(hovered_code) {
mainGame->ShowCardInfo(hovered_code);
}
if(pre_code)
imageManager.RemoveTexture(pre_code);
}
break;
}
case irr::EMIE_MOUSE_WHEEL: {
if(!mainGame->scrFilter->isVisible())
break;
if(event.MouseInput.Wheel < 0) {
if(mainGame->scrFilter->getPos() < mainGame->scrFilter->getMax())
mainGame->scrFilter->setPos(mainGame->scrFilter->getPos() + 1);
} else {
if(mainGame->scrFilter->getPos() > 0)
mainGame->scrFilter->setPos(mainGame->scrFilter->getPos() - 1);
}
SEvent e = event;
e.MouseInput.Event = irr::EMIE_MOUSE_MOVED;
mainGame->device->postEventFromUser(e);
break;
}
default:
break;
}
break;
}
case irr::EET_KEY_INPUT_EVENT: {
switch(event.KeyInput.Key) {
case irr::KEY_KEY_R: {
if(!event.KeyInput.PressedDown && !mainGame->HasFocus(EGUIET_EDIT_BOX))
mainGame->textFont->setTransparency(true);
break;
}
case irr::KEY_ESCAPE: {
if(!mainGame->HasFocus(EGUIET_EDIT_BOX))
mainGame->device->minimizeWindow();
break;
}
default:
break;
}
break;
}
default:
break;
}
return false;
}
int main (int argc, char** argv)
{
if (! vapi_initialize ())
{
vapi_full_screen ();
iapi_initialize ();
iapi_raw ();
iapi_noecho ();
iapi_mouse_tracking ();
int width = vapi_width ();
int height = vapi_height ();
int mx = 0;
int my = 0;
redraw (width, height, mx, my);
int key;
while ((key = iapi_getch ()) != EOF)
{
if (key == 'q')
break;
else if (key == 12)
{
width = vapi_width ();
height = vapi_height ();
redraw (width, height, mx, my);
}
else if (key == IAPI_MOUSE_1_CLICK ||
key == IAPI_MOUSE_2_CLICK ||
key == IAPI_MOUSE_3_CLICK ||
key == IAPI_MOUSE_4_CLICK ||
key == IAPI_MOUSE_5_CLICK ||
key == IAPI_MOUSE_1_MOVE ||
key == IAPI_MOUSE_2_MOVE ||
key == IAPI_MOUSE_3_MOVE ||
key == IAPI_MOUSE_4_MOVE ||
key == IAPI_MOUSE_5_MOVE ||
key == IAPI_MOUSE_RELEASE)
{
iapi_mouse_pos (&mx, &my);
mouse_pos (width, height, mx, my);
vapi_moveto (1, 1);
vapi_refresh ();
}
}
iapi_nomouse_tracking ();
iapi_echo ();
iapi_noraw ();
iapi_deinitialize ();
vapi_deinitialize ();
}
else
std::cout << "Your $TERM ("
<< getenv ("TERM")
<< ") is not supported."
<< std::endl;
return 0;
}
bool TessMeshApp::Init(){
bool res = App::Init();
if (!res) { return res; }
initMeshShader();
meshShaderProgram->use();
initMesh();
//mouse:
{
Shader vertexShader(GL_VERTEX_SHADER);
vertexShader.loadFromFile("shaders/mouse.vert");
vertexShader.compile();
Shader fragmentShader(GL_FRAGMENT_SHADER);
fragmentShader.loadFromFile("shaders/mouse.frag");
fragmentShader.compile();
// Shader geometryShader(GL_GEOMETRY_SHADER);
// geometryShader.loadFromFile("shaders/mouse.geom");
// geometryShader.compile();
mouseShaderProgram = new ShaderProgram();
mouseShaderProgram->attachShader(vertexShader);
mouseShaderProgram->attachShader(fragmentShader);
// mouseShaderProgram->attachShader(geometryShader);
mouseShaderProgram->linkProgram();
mouse = new Mesh();
vector<vec3> vertices;
vertices.push_back(vec3(0.0f, 0.0f, -5.0f));
vector<vec3> colors;
colors.push_back(vec3(1.0f, 0.0f, 0.0f));
vector<GLuint> indices;
indices.push_back(0);
mouse->addIndices(indices);
// position
{
Attribute positionAttrib;
positionAttrib.name = "position";
positionAttrib.num_of_components = 3;
positionAttrib.data_type = GL_FLOAT;
positionAttrib.buffer_type = GL_ARRAY_BUFFER;
mouse->addVBO(vertices, positionAttrib);
mouseShaderProgram->use();
positionAttrib.id = mouseShaderProgram->addAttribute(positionAttrib.name);
glEnableVertexAttribArray(positionAttrib.id);
glVertexAttribPointer(positionAttrib.id, positionAttrib.num_of_components, GL_FLOAT, GL_FALSE, 0, 0);
mouseShaderProgram->disable();
mouse->attributes.push_back(positionAttrib);
}
// color:
{
Attribute colorAttrib;
colorAttrib.name = "color";
colorAttrib.num_of_components = 3;
colorAttrib.data_type = GL_FLOAT;
colorAttrib.buffer_type = GL_ARRAY_BUFFER;
mouse->addVBO(colors, colorAttrib);
mouseShaderProgram->use();
colorAttrib.id = mouseShaderProgram->addAttribute(colorAttrib.name);
glEnableVertexAttribArray(colorAttrib.id);
glVertexAttribPointer(colorAttrib.id, colorAttrib.num_of_components, GL_FLOAT, GL_FALSE, 0, 0);
mouseShaderProgram->disable();
mouse->attributes.push_back(colorAttrib);
}
// uniforms:
{
mouseShaderProgram->use();
GLuint model = mouseShaderProgram->addUniform("model");
glUniformMatrix4fv(model, 1, GL_FALSE, glm::value_ptr(mesh->modelMatrix));
GLuint view = mouseShaderProgram->addUniform("view");
glUniformMatrix4fv(view, 1, GL_FALSE, glm::value_ptr(camera.view));
GLuint projection = mouseShaderProgram->addUniform("projection");
glUniformMatrix4fv(projection, 1, GL_FALSE, glm::value_ptr(camera.projection));
GLuint mousePosition = mouseShaderProgram->addUniform("mousePosition");
vec3 mouse_pos(1.0f, 0.0f, -5.0f);
glUniform3fv(mousePosition, 1, glm::value_ptr(mouse_pos));
mouseShaderProgram->disable();
}
}
return res;
}
