void MedianFlow::filterNCC(const vector<TYPE_MF_PT> &initialPts, const vector<TYPE_MF_PT> &FPts, vector<int> &rejected)
{
int size = int(initialPts.size());
vector<pair<float, int> > V;
for(int i = 0; i < size; i++)
{
if(rejected[i] & MF_REJECT_OFERROR) continue;
if(!isPointInside(initialPts[i], MF_HALF_PATCH_SIZE)) continue;
if(!isPointInside(FPts[i], MF_HALF_PATCH_SIZE)) continue;
Point2d win(MF_HALF_PATCH_SIZE, MF_HALF_PATCH_SIZE);
Point2d pt1(initialPts[i].x, initialPts[i].y);
Point2d pt2(FPts[i].x, FPts[i].y);
// must be int
Rect_<int> rect0(pt1 - win, pt1 + win);
Rect_<int> rect1(pt2 - win, pt2 + win);
float ncc = calcNCC(this->prevImg(rect0), this->nextImg(rect1));
V.push_back(make_pair(ncc, i));
}
sort(V.begin(), V.end(), compare);
for(int i = int(V.size()) / 2; i < V.size(); i++)
{
rejected[V[i].second] |= MF_REJECT_NCC;
}
}
bool OsmAnd::Frustum2D::test(const PointF& lp0, const PointF& lp1) const
{
// Check if any of line points is inside.
// This case covers inner line and partially inner line (that has one vertex inside).
if (isPointInside(lp0) || isPointInside(lp1))
return true;
// Check if line 'lp0-lp1' intersects any of edges.
// This case covers intersecting line, that has start and stop outside of frustum.
return
testLineLineIntersection(lp0, lp1, p0, p1) ||
testLineLineIntersection(lp0, lp1, p1, p2) ||
testLineLineIntersection(lp0, lp1, p2, p3) ||
testLineLineIntersection(lp0, lp1, p3, p0);
}
Widget* Widget::getElementFromPoint( const Point& point )
{
Widget* target = 0;
// we have to search from back to front, because later children
// might be drawn over the top of earlier ones.
ChildIterator it = _d->children.getLast();
if (isVisible())
{
while(it != _d->children.end())
{
target = (*it)->getElementFromPoint(point);
if (target)
return target;
--it;
}
}
if (isVisible() && isPointInside(point))
target = this;
return target;
}
bool FloorFace::intersectRay(const Math::Ray &ray, Math::Vector3d &intersection) const {
// Compute the triangle plane normal
Math::Vector3d n = Math::Vector3d::crossProduct(_vertices[1] - _vertices[0], _vertices[2] - _vertices[0]);
if (n == Math::Vector3d()) {
return false; // We don't handle degenerate triangles
}
// Point on triangle plane: dot(P - _vertices[0], n) = 0
// Point on ray: P = origin + r * direction
// Point on both => r = - dot(n, origin - _vertices[0]) / dot(n, direction)
float num = -Math::Vector3d::dotProduct(n, ray.origin() - _vertices[0]);
float denom = Math::Vector3d::dotProduct(n, ray.direction());
if (fabs(denom) < 0.00001) {
// The ray is parallel to the plane
return false;
}
float r = num / denom;
if (r < 0.0) {
// The ray goes away from the triangle
return false;
}
// Compute the intersection point between the triangle plane and the ray
intersection = ray.origin() + r * ray.direction();
// Check the intersection point is inside the triangle
return isPointInside(intersection);
}
bool MGui2d::isMouseInside(void)
{
if(isPointInside(getMouseLocalPosition()))
return true;
return false;
}
bool Triangle::intersects(Triangle t2)
{
vector3df outIntersection;
if(getIntersectionWithLimitedLine (line3df(t2.pointA,t2.pointB),outIntersection))
return true;
if(getIntersectionWithLimitedLine (line3df(t2.pointA,t2.pointB),outIntersection))
return true;
if(getIntersectionWithLimitedLine (line3df(t2.pointA,t2.pointB),outIntersection))
return true;
#if 0
if(isPointInside(t2.pointA))
return true;
if(isPointInside(t2.pointB))
return true;
if(isPointInside(t2.pointC))
return true;
#endif
return false;
}
bool OsmAnd::Frustum2D::test(const AreaF& area) const
{
const auto a0 = area.topLeft;
const auto a1 = area.topRight();
const auto a2 = area.bottomRight;
const auto a3 = area.bottomLeft();
// Check if any vertex of area is inside.
// This case covers inner area and partially inner area (that has at least 1 vertex inside)
if (isPointInside(a0) || isPointInside(a1) || isPointInside(a2) || isPointInside(a3))
return true;
// Check if any area edge intersects any of frustum edges.
// This case covers intersecting area that has no vertex inside frustum.
if (
testLineLineIntersection(a0, a1, p0, p1) ||
testLineLineIntersection(a0, a1, p1, p2) ||
testLineLineIntersection(a0, a1, p2, p3) ||
testLineLineIntersection(a0, a1, p3, p0) ||
testLineLineIntersection(a1, a2, p0, p1) ||
testLineLineIntersection(a1, a2, p1, p2) ||
testLineLineIntersection(a1, a2, p2, p3) ||
testLineLineIntersection(a1, a2, p3, p0) ||
testLineLineIntersection(a2, a3, p0, p1) ||
testLineLineIntersection(a2, a3, p1, p2) ||
testLineLineIntersection(a2, a3, p2, p3) ||
testLineLineIntersection(a2, a3, p3, p0) ||
testLineLineIntersection(a3, a0, p0, p1) ||
testLineLineIntersection(a3, a0, p1, p2) ||
testLineLineIntersection(a3, a0, p2, p3) ||
testLineLineIntersection(a3, a0, p3, p0))
return true;
// Check if frustum is totally inside area.
return
area.contains(p0) ||
area.contains(p1) ||
area.contains(p2) ||
area.contains(p3);
}
//! sends a click Returns:
//! 0 if click went outside of the element,
//! 1 if a valid button was clicked,
//! 2 if a nonclickable element was clicked
u32 CGUIContextMenu::sendClick(const core::position2d<s32>& p)
{
u32 t = 0;
// get number of open submenu
s32 openmenu = -1;
s32 j;
for (j=0; j<(s32)Items.size(); ++j)
if (Items[j].SubMenu && Items[j].SubMenu->isVisible())
{
openmenu = j;
break;
}
// delegate click operation to submenu
if (openmenu != -1)
{
t = Items[j].SubMenu->sendClick(p);
if (t != 0)
return t; // clicked something
}
// check click on myself
if (isPointInside(p) &&
(u32)HighLighted < Items.size())
{
if (!Items[HighLighted].Enabled ||
Items[HighLighted].IsSeparator ||
Items[HighLighted].SubMenu)
return 2;
if ( Items[HighLighted].AutoChecking )
{
Items[HighLighted].Checked = Items[HighLighted].Checked ? false : true;
}
SEvent event;
event.EventType = EET_GUI_EVENT;
event.GUIEvent.Caller = this;
event.GUIEvent.Element = 0;
event.GUIEvent.EventType = EGET_MENU_ITEM_SELECTED;
if (EventParent)
EventParent->OnEvent(event);
else if (Parent)
Parent->OnEvent(event);
return 1;
}
return 0;
}
bool isPointInside(const Vec2f &point, const vector<vector<Vec2f>> &polygons)
{
int numPathsInside = 0;
for (auto &polygon : polygons)
{
if (isPointInside(point, polygon))
{
numPathsInside++;
}
}
return (numPathsInside % 2) == 1;
}
static kernelWindowComponent *eventComp(kernelWindowComponent *component,
windowEvent *event)
{
// Determine which component should receive a window event at the supplied
// coordinates. First look for any component at the coordinates, and if
// applicable, call that component to allow it to specify a particular
// subcomponent to receive the event.
kernelWindowContainer *container = component->data;
kernelWindowComponent *item = NULL;
int count;
kernelDebug(debug_gui, "WindowContainer \"%s\" container \"%s\" get "
"component", component->window->title, container->name);
for (count = 0; count < container->numComponents; count ++)
{
item = container->components[count];
// If not visible or enabled, skip it
if (!(item->flags & WINFLAG_VISIBLE) ||
!(item->flags & WINFLAG_ENABLED))
{
continue;
}
// Are the coordinates inside this component?
if (isPointInside(event->xPosition, event->yPosition,
makeComponentScreenArea(item)))
{
kernelDebug(debug_gui, "WindowContainer \"%s\" container \"%s\" "
"found component", component->window->title, container->name);
// The coordinates are inside this component. Does it want to
// specify a subcomponent?
if (item->eventComp)
return (item->eventComp(item, event));
else
return (item);
}
}
// Nothing found. Return the container itself.
return (component);
}
float BoundingBox::distanceTo(const Vector3F & pnt) const
{
if(isPointInside(pnt)) return -1.f;
float dx = getMin(0) - pnt.x;
dx = dx > 0.f ? dx : 0.f;
const float dx1 = pnt.x - getMax(0);
dx = dx > dx1 ? dx : dx1;
float dy = getMin(1) - pnt.y;
dy = dy > 0.f ? dy : 0.f;
const float dy1 = pnt.y - getMax(1);
dy = dy > dy1 ? dy : dy1;
float dz = getMin(2) - pnt.z;
dz = dz > 0.f ? dz : 0.f;
const float dz1 = pnt.z - getMax(2);
dz = dz > dz1 ? dz : dz1;
return sqrt(dx * dx + dy * dy + dz * dz);
}
//! called if an event happened
bool ScrollBar::onEvent(const NEvent& event)
{
if (isEnabled())
{
switch(event.EventType)
{
case OC3_KEYBOARD_EVENT:
if (event.KeyboardEvent.PressedDown)
{
const int oldPos = _value;
bool absorb = true;
switch (event.KeyboardEvent.Key)
{
case KEY_LEFT:
case KEY_UP:
setPos(_value-_smallStep);
break;
case KEY_RIGHT:
case KEY_DOWN:
setPos(_value+_smallStep);
break;
case KEY_HOME:
setPos(_minValue);
break;
case KEY_PRIOR:
setPos(_value-_largeStep);
break;
case KEY_END:
setPos(_maxVallue);
break;
case KEY_NEXT:
setPos(_value+_largeStep);
break;
default:
absorb = false;
}
if (_value != oldPos)
{
_resolvePositionChanged();
}
if (absorb)
return true;
}
break;
case OC3_GUI_EVENT:
if (event.GuiEvent.EventType == OC3_BUTTON_CLICKED)
{
if (event.GuiEvent.Caller == _d->upButton)
{
setPos(_value-_smallStep);
}
else if (event.GuiEvent.Caller == _d->downButton)
{
setPos(_value+_smallStep);
}
_resolvePositionChanged();
return true;
}
else
if (event.GuiEvent.EventType == OC3_ELEMENT_FOCUS_LOST)
{
if (event.GuiEvent.Caller == this)
_dragging = false;
}
break;
case OC3_MOUSE_EVENT:
{
_d->cursorPos =event.MouseEvent.getPosition();
bool isInside = isPointInside ( _d->cursorPos );
switch(event.MouseEvent.Event)
{
case OC3_MOUSE_WHEEL:
if( isFocused() )
{
// thanks to a bug report by REAPER
// thanks to tommi by tommi for another bugfix
// everybody needs a little thanking. hallo niko!;-)
setPos( getPos() +
( (int)event.MouseEvent.Wheel * _smallStep * (_horizontal ? 1 : -1 ) )
);
_resolvePositionChanged();
return true;
}
break;
case OC3_LMOUSE_PRESSED_DOWN:
{
if (isInside)
{
_dragging = true;
_draggedBySlider = _d->sliderRect.isPointInside( _d->cursorPos );
_trayClick = !_draggedBySlider;
_desiredPos = _getPosFromMousePos( _d->cursorPos );
_environment->setFocus ( this );
return true;
}
break;
}
case OC3_LMOUSE_LEFT_UP:
case OC3_MOUSE_MOVED:
{
if ( !event.MouseEvent.isLeftPressed () )
{
_draggedBySlider = false;
_dragging = false;
}
if ( !_dragging )
return isInside;
if ( event.MouseEvent.Event == OC3_LMOUSE_LEFT_UP )
{
_dragging = false;
}
const int newPos = _getPosFromMousePos( _d->cursorPos );
const int oldPos = _value;
if (!_draggedBySlider)
{
if ( isInside )
{
_draggedBySlider = _d->sliderRect.isPointInside( _d->cursorPos );
_trayClick = !_draggedBySlider;
}
if( _draggedBySlider )
{
setPos(newPos);
}
else
{
_trayClick = false;
if (event.MouseEvent.Event == OC3_MOUSE_MOVED)
{
return isInside;
}
}
}
if (_draggedBySlider)
{
setPos(newPos);
}
else
{
_desiredPos = newPos;
}
if (_value != oldPos )
{
_resolvePositionChanged();
}
return isInside;
} break;
default:
break;
}
} break;
default:
break;
}
}
return Widget::onEvent(event);
}
bool GUITable::OnEvent(const SEvent &event)
{
if (!isEnabled())
return IGUIElement::OnEvent(event);
if (event.EventType == EET_KEY_INPUT_EVENT) {
if (event.KeyInput.PressedDown && (
event.KeyInput.Key == KEY_DOWN ||
event.KeyInput.Key == KEY_UP ||
event.KeyInput.Key == KEY_HOME ||
event.KeyInput.Key == KEY_END ||
event.KeyInput.Key == KEY_NEXT ||
event.KeyInput.Key == KEY_PRIOR)) {
s32 offset = 0;
switch (event.KeyInput.Key) {
case KEY_DOWN:
offset = 1;
break;
case KEY_UP:
offset = -1;
break;
case KEY_HOME:
offset = - (s32) m_visible_rows.size();
break;
case KEY_END:
offset = m_visible_rows.size();
break;
case KEY_NEXT:
offset = AbsoluteRect.getHeight() / m_rowheight;
break;
case KEY_PRIOR:
offset = - (s32) (AbsoluteRect.getHeight() / m_rowheight);
break;
default:
break;
}
s32 old_selected = m_selected;
s32 rowcount = m_visible_rows.size();
if (rowcount != 0) {
m_selected = rangelim(m_selected + offset, 0, rowcount-1);
autoScroll();
}
if (m_selected != old_selected)
sendTableEvent(0, false);
return true;
}
else if (event.KeyInput.PressedDown && (
event.KeyInput.Key == KEY_LEFT ||
event.KeyInput.Key == KEY_RIGHT)) {
// Open/close subtree via keyboard
if (m_selected >= 0) {
int dir = event.KeyInput.Key == KEY_LEFT ? -1 : 1;
toggleVisibleTree(m_selected, dir, true);
}
return true;
}
else if (!event.KeyInput.PressedDown && (
event.KeyInput.Key == KEY_RETURN ||
event.KeyInput.Key == KEY_SPACE)) {
sendTableEvent(0, true);
return true;
}
else if (event.KeyInput.Key == KEY_ESCAPE ||
event.KeyInput.Key == KEY_SPACE) {
// pass to parent
}
else if (event.KeyInput.PressedDown && event.KeyInput.Char) {
// change selection based on text as it is typed
s32 now = getTimeMs();
if (now - m_keynav_time >= 500)
m_keynav_buffer = L"";
m_keynav_time = now;
// add to key buffer if not a key repeat
if (!(m_keynav_buffer.size() == 1 &&
m_keynav_buffer[0] == event.KeyInput.Char)) {
m_keynav_buffer.append(event.KeyInput.Char);
}
// find the selected item, starting at the current selection
// don't change selection if the key buffer matches the current item
s32 old_selected = m_selected;
s32 start = MYMAX(m_selected, 0);
s32 rowcount = m_visible_rows.size();
for (s32 k = 1; k < rowcount; ++k) {
s32 current = start + k;
if (current >= rowcount)
current -= rowcount;
if (doesRowStartWith(getRow(current), m_keynav_buffer)) {
m_selected = current;
break;
}
}
autoScroll();
if (m_selected != old_selected)
sendTableEvent(0, false);
return true;
}
}
if (event.EventType == EET_MOUSE_INPUT_EVENT) {
core::position2d<s32> p(event.MouseInput.X, event.MouseInput.Y);
if (event.MouseInput.Event == EMIE_MOUSE_WHEEL) {
m_scrollbar->setPos(m_scrollbar->getPos() +
(event.MouseInput.Wheel < 0 ? -3 : 3) *
- (s32) m_rowheight / 2);
return true;
}
// Find hovered row and cell
bool really_hovering = false;
s32 row_i = getRowAt(p.Y, really_hovering);
const Cell *cell = NULL;
if (really_hovering) {
s32 cell_j = getCellAt(p.X, row_i);
if (cell_j >= 0)
cell = &(getRow(row_i)->cells[cell_j]);
}
// Update tooltip
setToolTipText(cell ? m_strings[cell->tooltip_index].c_str() : L"");
// Fix for #1567/#1806:
// IGUIScrollBar passes double click events to its parent,
// which we don't want. Detect this case and discard the event
if (event.MouseInput.Event != EMIE_MOUSE_MOVED &&
m_scrollbar->isVisible() &&
m_scrollbar->isPointInside(p))
return true;
if (event.MouseInput.isLeftPressed() &&
(isPointInside(p) ||
event.MouseInput.Event == EMIE_MOUSE_MOVED)) {
s32 sel_column = 0;
bool sel_doubleclick = (event.MouseInput.Event
== EMIE_LMOUSE_DOUBLE_CLICK);
bool plusminus_clicked = false;
// For certain events (left click), report column
// Also open/close subtrees when the +/- is clicked
if (cell && (
event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN ||
event.MouseInput.Event == EMIE_LMOUSE_DOUBLE_CLICK ||
event.MouseInput.Event == EMIE_LMOUSE_TRIPLE_CLICK)) {
sel_column = cell->reported_column;
if (cell->content_type == COLUMN_TYPE_TREE)
plusminus_clicked = true;
}
if (plusminus_clicked) {
if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) {
toggleVisibleTree(row_i, 0, false);
}
}
else {
// Normal selection
s32 old_selected = m_selected;
m_selected = row_i;
autoScroll();
if (m_selected != old_selected ||
sel_column >= 1 ||
sel_doubleclick) {
sendTableEvent(sel_column, sel_doubleclick);
}
// Treeview: double click opens/closes trees
if (m_has_tree_column && sel_doubleclick) {
toggleVisibleTree(m_selected, 0, false);
}
}
}
return true;
}
if (event.EventType == EET_GUI_EVENT &&
event.GUIEvent.EventType == gui::EGET_SCROLL_BAR_CHANGED &&
event.GUIEvent.Caller == m_scrollbar) {
// Don't pass events from our scrollbar to the parent
return true;
}
return IGUIElement::OnEvent(event);
}
bool GUIFCCharacterItem::OnEvent(const SEvent& event)
{
bool bHandled = false;
switch ( event.EventType )
{
case EET_GUI_EVENT:
{
s32 elemID = event.GUIEvent.Caller->getID();
switch ( event.GUIEvent.EventType )
{
case EGET_ELEMENT_HOVERED:
{
if ( event.GUIEvent.Caller == this )
{
SetHighlight(true);
bHandled = true;
}
}
break;
case EGET_ELEMENT_LEFT:
{
if ( event.GUIEvent.Caller == this )
{
SetHighlight(false);
bHandled = true;
}
}
break;
default:
break;
}
}
break;
case EET_MOUSE_INPUT_EVENT:
{
switch ( event.MouseInput.Event )
{
case EMIE_LMOUSE_LEFT_UP:
{
if ( isPointInside( core::position2d<s32>( event.MouseInput.X, event.MouseInput.Y ) ) )
{
Character* pChar = GetCharacter();
if ( m_pContainer && pChar )
{
FCViewEvent e( VE_CharacterSelected, pChar->GetID() );
m_pContainer->GetController()->OnViewEvent(e);
bHandled = true;
}
}
}
break;
default:
break;
}
}
break;
default:
break;
}
return bHandled;
}
bool Polyhedron<Real>::checkIfAveragePointIsInside() const
{
vector3<Real> averagePoint = getAveragePoint();
return isPointInside(averagePoint);
}
int Player::collisionType(){
// ESQUINA SUPERIOR IZQUIERDA dot->x dot->y
// ESQUINA SUPERIOR DERECHA dot->x + DOT_WIDTH dot->y
// ESQUINA INFERIOR IZQUIERDA dot->x dot->y + DOT_HEIGHT
// ESQUINA INFERIOR DERECHA dot->x + DOT_WIDTH dot->y + DOT_HEIGHT
float posX = dot->x;
float posXMid = dot->x + (dot->DOT_WIDTH/2);
float posXEnd = dot->x + dot->DOT_WIDTH;
float posY = dot->y, posYMid = dot->y+ dot->DOT_HEIGHT/2, posYEnd = dot->y + dot->DOT_HEIGHT;
if(this->isColliding){
this->wasColliding = true;
} else {
this->wasColliding =false;
}
this->isColliding = false;
if (!this->wasColliding){
if( isPointInside(posX,posY)
&&
isPointInside(posXMid,posY)
||
isPointInside(posXMid,posY)
&&
isPointInside(posXEnd,posY)
){
this->isColliding = true;
return TOP2;
} else if (
isPointInside(posX,posYEnd)
&& isPointInside(posXMid,posYEnd)
||
isPointInside(posXMid,posYEnd)
&& isPointInside(posXEnd,posYEnd)
){
this->isColliding = true;
return BOT2;
}else if (
isPointInside(posX,posY)
&&
isPointInside(posX,posYMid)
||
isPointInside(posX,posYMid)
&& isPointInside(posX,posYEnd)
){
this->isColliding = true;
return LEFT2;
}else if (
isPointInside(posXEnd,posY)
&&
isPointInside(posXEnd,posYMid)
||
isPointInside(posXEnd,posYMid)
&& isPointInside(posXEnd,posYEnd)
){
this->isColliding = true;
return RIGHT2;
}else if (isPointInside(posX,posY)){
return CORNERUL2;
}else if(isPointInside(posX,posYEnd)){
return CORNERDL2;
}else if(isPointInside(posXEnd,posY)){
return CORNERUR2;
}else if(isPointInside(posXEnd,posYEnd)){
return CORNERDR2;
}
}
return 0;
}
bool OsmAnd::Frustum2D::test(const PointF& p) const
{
return isPointInside(p);
}
bool
Collider::operator>(const Vec2d& p) const
{
return isPointInside(p);
}
void
WorkerBee::onState(State state, sf::Time dt)
{
Vec2d empty(-1.0, -1.0);
// first state
if (state == IN_HIVE) {
// if bee has pollen transfer it to hive
if (getPollen() > 0) {
transferPollen(dt);
flower_location_ = empty;
setDebugStatus("in_hive_leaving_pollen");
} else {
// if bee has not enough energy to leave hive, eat its nectar
if (getEnergy() < energy_leave_hive_
&& getHive().getNectar() > 0) {
setDebugStatus("in_hive_eating");
eatFromHive(dt);
}
// if there is a flower in memory and enough energy, target move
// to this flower
else if (flower_location_ != empty
&& getEnergy() > energy_collect_pollen_) {
setDebugStatus("in_hive_leaving");
setMoveTarget(flower_location_);
// change state to to flower
nextState();
} else {
setDebugStatus("in_hive_no_flower");
}
}
}
// second state
else if (state == TO_FLOWER) {
setDebugStatus("to_flower");
if (getEnergy() < energy_collect_pollen_) {
nextState();
nextState();
}
Flower* flower = getAppEnv().getCollidingFlower(getVisionRange());
if (flower) {
setMoveTarget(flower->getPosition());
setMoveState(MoveState::TARGET);
if (isPointInside(flower->getPosition())) {
nextState();
}
} else if (isPointInside(flower_location_)) {
// go back to hive and clear location
nextState();
nextState();
setFlowerLocation(Vec2d(-1,-1));
}
}
// third state
else if (state == COLLECT_POLLEN) {
// if there is a flower at flower location and it has pollen and
// bee has not enough pollen, eat pollen from flower
Flower* flower(getAppEnv().getCollidingFlower(getCollider()));
if ((getPollen() < max_pollen_)
&& (flower != nullptr)
&& (flower->getPollen() > 0)) {
eatPollen(flower, dt);
} else {
// else skip collection
nextState();
}
} else if (state == RETURN_HIVE) {
// if bee is in hive change state to in hive
if (getHive().isColliderInside(getCollider())) {
nextState();
}
}
}
//! called if an event happened.
bool CGUIScrollBar::OnEvent(const SEvent& event)
{
if (isEnabled())
{
switch (event.EventType)
{
case EET_KEY_INPUT_EVENT:
if (event.KeyInput.PressedDown)
{
const SINT32 oldPos = Pos;
bool absorb = true;
switch (event.KeyInput.Key)
{
case KEY_LEFT:
case KEY_UP:
setPos(Pos - SmallStep);
break;
case KEY_RIGHT:
case KEY_DOWN:
setPos(Pos + SmallStep);
break;
case KEY_HOME:
setPos(Min);
break;
case KEY_PRIOR:
setPos(Pos - LargeStep);
break;
case KEY_END:
setPos(Max);
break;
case KEY_NEXT:
setPos(Pos + LargeStep);
break;
default:
absorb = false;
}
if (Pos != oldPos)
{
SEvent newEvent;
newEvent.EventType = EET_GUI_EVENT;
newEvent.GUIEvent.Caller = this;
newEvent.GUIEvent.Element = 0;
newEvent.GUIEvent.EventType = EGET_SCROLL_BAR_CHANGED;
Parent->OnEvent(newEvent);
}
if (absorb)
return true;
}
break;
case EET_GUI_EVENT:
if (event.GUIEvent.EventType == EGET_BUTTON_CLICKED)
{
if (event.GUIEvent.Caller == UpButton)
setPos(Pos - SmallStep);
else
if (event.GUIEvent.Caller == DownButton)
setPos(Pos + SmallStep);
SEvent newEvent;
newEvent.EventType = EET_GUI_EVENT;
newEvent.GUIEvent.Caller = this;
newEvent.GUIEvent.Element = 0;
newEvent.GUIEvent.EventType = EGET_SCROLL_BAR_CHANGED;
Parent->OnEvent(newEvent);
return true;
}
else
if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUS_LOST)
{
if (event.GUIEvent.Caller == this)
Dragging = false;
}
break;
case EET_MOUSE_INPUT_EVENT:
{
const Position2d p(event.MouseInput.X, event.MouseInput.Y);
bool isInside = isPointInside(p);
switch (event.MouseInput.Event)
{
case EMIE_MOUSE_WHEEL:
if (Environment->hasFocus(this))
{
// thanks to a bug report by REAPER
// thanks to tommi by tommi for another bugfix
// everybody needs a little thanking. hallo niko!;-)
setPos(getPos() +
((event.MouseInput.Wheel < 0 ? -1 : 1) * SmallStep * (Horizontal ? 1 : -1))
);
SEvent newEvent;
newEvent.EventType = EET_GUI_EVENT;
newEvent.GUIEvent.Caller = this;
newEvent.GUIEvent.Element = 0;
newEvent.GUIEvent.EventType = EGET_SCROLL_BAR_CHANGED;
Parent->OnEvent(newEvent);
return true;
}
break;
case EMIE_LMOUSE_PRESSED_DOWN:
{
if (isInside)
{
Dragging = true;
DraggedBySlider = SliderRect.isPointInside(p);
TrayClick = !DraggedBySlider;
DesiredPos = getPosFromMousePos(p);
Environment->setFocus(this);
return true;
}
break;
}
case EMIE_LMOUSE_LEFT_UP:
case EMIE_MOUSE_MOVED:
{
if (!event.MouseInput.isLeftPressed())
Dragging = false;
if (!Dragging)
{
if (event.MouseInput.Event == EMIE_MOUSE_MOVED)
break;
return isInside;
}
if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
Dragging = false;
const SINT32 newPos = getPosFromMousePos(p);
const SINT32 oldPos = Pos;
if (!DraggedBySlider)
{
if (isInside)
{
DraggedBySlider = SliderRect.isPointInside(p);
TrayClick = !DraggedBySlider;
}
if (DraggedBySlider)
{
setPos(newPos);
}
else
{
TrayClick = false;
if (event.MouseInput.Event == EMIE_MOUSE_MOVED)
return isInside;
}
}
if (DraggedBySlider)
{
setPos(newPos);
}
else
{
DesiredPos = newPos;
}
if (Pos != oldPos && Parent)
{
SEvent newEvent;
newEvent.EventType = EET_GUI_EVENT;
newEvent.GUIEvent.Caller = this;
newEvent.GUIEvent.Element = 0;
newEvent.GUIEvent.EventType = EGET_SCROLL_BAR_CHANGED;
Parent->OnEvent(newEvent);
}
return isInside;
} break;
default:
break;
}
} break;
default:
break;
}
}
return IGUIElement::OnEvent(event);
}
int Block::collisionType(){
// ESQUINA SUPERIOR IZQUIERDA dot->x dot->y
// ESQUINA SUPERIOR DERECHA dot->x + DOT_WIDTH dot->y
// ESQUINA INFERIOR IZQUIERDA dot->x dot->y + DOT_HEIGHT
// ESQUINA INFERIOR DERECHA dot->x + DOT_WIDTH dot->y + DOT_HEIGHT
int x_off = (cos (dot->angle*PI/180) * dot->velocity );
int y_off = sin (dot->angle*PI/180) * dot->velocity;
float posX= dot->x + x_off;
float posXMid = dot->x + (dot->DOT_WIDTH/2) + x_off;
float posXEnd= dot->x + dot->DOT_WIDTH + x_off;
float posY = dot->y - y_off, posYMid = dot->y+ dot->DOT_HEIGHT/2 - y_off, posYEnd = dot->y + dot->DOT_HEIGHT - y_off;
if(this->isColliding){
this->wasColliding = true;
} else {
this->wasColliding =false;
}
this->isColliding = false;
if (!this->wasColliding){
if( isPointInside(posX,posY)
&&
isPointInside(posXMid,posY)
||
isPointInside(posXMid,posY)
&&
isPointInside(posXEnd,posY)
){
this->isColliding = true;
return TOP;
} else if (
isPointInside(posX,posYEnd)
&& isPointInside(posXMid,posYEnd)
||
isPointInside(posXMid,posYEnd)
&& isPointInside(posXEnd,posYEnd)
){
this->isColliding = true;
return BOT;
}else if (
isPointInside(posX,posY)
&&
isPointInside(posX,posYMid)
||
isPointInside(posX,posYMid)
&& isPointInside(posX,posYEnd)
){
this->isColliding = true;
return LEFT;
}else if (
isPointInside(posXEnd,posY)
&&
isPointInside(posXEnd,posYMid)
||
isPointInside(posXEnd,posYMid)
&& isPointInside(posXEnd,posYEnd)
){
this->isColliding = true;
return RIGHT;
}else if (isPointInside(posX,posY)){
return CORNERUL;
}else if(isPointInside(posX,posYEnd)){
return CORNERDL;
}else if(isPointInside(posXEnd,posY)){
return CORNERUR;
}else if(isPointInside(posXEnd,posYEnd)){
return CORNERDR;
}
}
return 0;
}
bool AABB2::isOverlappingWithDisc( const Disc2& disc ) const
{
/************************************************************************/
/*
* This function checks the disc's distance in the 9 possible regions in and around an AABB2
* 1 Represents the area of the box, 2-9 represent areas around the box, bounded by extensions of
* the edges that make up the box.
*
* 8 | 4 | 9
* ____|____|_____
* | |
* 3 | 1 | 5
* ____|____|_____
* 7 | 2 | 6
*
* 1: Center is inside the box
* 2-5: Center's distance to an edge can determined easily with straight lines
* 6-9: Disc's center's distance to square must be determined with a diagonal
* */
/************************************************************************/
const Vector2 discCenterLoc = disc.getCenterLocation();
//Case 1x
if( isPointInside( discCenterLoc ))
{
return true;
}
const float discRadius = disc.getRadius();
// Cases 2, 4
if( discCenterLoc.x < m_Max.x && discCenterLoc.x > m_Min.x )
{
if( discCenterLoc.y > m_Max.y && ( discCenterLoc.y - m_Max.y <= discRadius ) )
{
return true;
}
if( discCenterLoc.y < m_Min.y && ( m_Min.y - discCenterLoc.y <= discRadius ) )
{
return true;
}
}
// Cases 3, 5
if( discCenterLoc.y < m_Max.y && discCenterLoc.y > m_Min.y )
{
if( discCenterLoc.x > m_Max.x && ( discCenterLoc.x - m_Max.x <= discRadius ) )
{
return true;
}
if( discCenterLoc.x < m_Min.x && ( m_Min.x - discCenterLoc.x <= discRadius ) )
{
return true;
}
}
// Case 6, 7
if( discCenterLoc.y < m_Min.y )
{
if( discCenterLoc.x > m_Max.x )
{
//Check distance to bottom right corner
return disc.isPointInside( Vector2( m_Max.x, m_Min.y ) );
}
if( discCenterLoc.x < m_Min.x )
{
//Check distance to bottom left corner, min
return disc.isPointInside( m_Min );
}
}
// Case 8, 9
if( discCenterLoc.y > m_Max.y )
{
// Check distance to top right corner, max
if( discCenterLoc.x > m_Max.x )
{
return disc.isPointInside( m_Max );
}
// Check distance to top left corner
if( discCenterLoc.x < m_Min.x )
{
return disc.isPointInside( Vector2( m_Min.x, m_Max.y ));
}
}
return false;;
}
xdl::xdl_bool Frustum::isPointInside(const tmath::vec3& point) {
return isPointInside(point.x, point.z, point.z);
}
