void LineClipping_Clip(const struct LineClipping_Rectangle *r, struct LineClipping_Segment *s, int *done) { const int maxIter = 4; int outcode0, outcode1, i; double x, y; /*Cohen-Sutherland line clipping algorithm*/ outcode0 = Outcode(s->x0, s->y0, r); outcode1 = Outcode(s->x1, s->y1, r); i = 0; while (! Inside(outcode0, outcode1) && ! SameSide(outcode0, outcode1) && (i < maxIter)) { if (outcode0 != 0) { GetIntersection(r, s, outcode0, &x, &y); s->x0 = x; s->y0 = y; outcode0 = Outcode(x, y, r); } else { GetIntersection(r, s, outcode1, &x, &y); s->x1 = x; s->y1 = y; outcode1 = Outcode(x, y, r); } i++; } assert(i < maxIter); *done = Inside(outcode0, outcode1); }
bool C4Network2IO::Execute(int iTimeout, pollfd *) { tLastExecute = C4TimeMilliseconds::Now(); // check for timeout CheckTimeout(); // ping all open connections if (!Inside(tLastPing, tLastExecute - C4NetPingFreq, tLastExecute)) { Ping(); tLastPing = tLastExecute; } // do statistics if (!Inside(tLastStatistic, tLastExecute - C4NetStatisticsFreq, tLastExecute)) { GenerateStatistics(tLastExecute - tLastStatistic); tLastStatistic = tLastExecute; } // resources ::Network.ResList.OnTimer(); // ok return true; }
void C4EditCursor::FrameSelection() { ClearSelection(); C4Object *cobj; C4ObjectLink *clnk; for (clnk=::Objects.First; clnk && (cobj=clnk->Obj); clnk=clnk->Next) if (cobj->Status) if (cobj->OCF & OCF_NotContained) { if (Inside(cobj->GetX(),Min(X,X2),Max(X,X2)) && Inside(cobj->GetY(),Min(Y,Y2),Max(Y,Y2))) AddToSelection(cobj); } OnSelectionChanged(); }
static bool FnLayerSetPixel(C4PropList * _this, int32_t x, int32_t y, const C4Value& fg_value_c4v, const C4Value& bg_value_c4v) { // Layer script function: Set pixel at position x,y to to_value in _this layer C4MapScriptLayer *layer = _this->GetMapScriptLayer(); if (!layer) return false; uint8_t fg, bg; if (fg_value_c4v.GetType() == C4V_Nil) { fg = layer->GetPix(x,y,0); } else { const C4Value& val = fg_value_c4v; C4String *str = val.getStr(); if (str != NULL) { if (!TexColSingle(str->GetCStr(), fg)) throw C4AulExecError("MapLayer::SetPixel: Trying to set invalid pixel value."); } else { if (!Inside(val.getInt(), 0, 255)) throw C4AulExecError("MapLayer::SetPixel: Trying to set invalid pixel value."); fg = val.getInt(); } } if (bg_value_c4v.GetType() == C4V_Nil) { bg = layer->GetBackPix(x,y,0); } else { const C4Value& val = bg_value_c4v; C4String *str = val.getStr(); if (str != NULL) { if (!TexColSingle(str->GetCStr(), bg)) throw C4AulExecError("MapLayer::SetPixel: Trying to set invalid pixel value."); } else { if (!Inside(val.getInt(), 0, 255)) throw C4AulExecError("MapLayer::SetPixel: Trying to set invalid pixel value."); bg = val.getInt(); } } return layer->SetPix(x,y,fg,bg); }
global func CyclopsExecuteIdle(fx) { if (!Inside(fx.cyclops->GetX()-fx.home_x, -5,5) || !Inside(fx.cyclops->GetY()-fx.home_y, -15,15)) { fx.cyclops->SetCommand("MoveTo", nil, fx.home_x, fx.home_y); } else { fx.cyclops->SetCommand("None"); fx.cyclops->SetComDir(COMD_Stop); fx.cyclops->SetDir(fx.home_dir); } return true; }
void Is_draw_active(float _icon_pos_y)//Insideがtrueのときさらに判定 { if (Inside(_icon_pos_y, -185, -215)) { judge_num =JUDGE::EXCELENT; } else if (Inside(_icon_pos_y, -165, -185) || Inside(_icon_pos_y, -215, -235)) { judge_num = JUDGE::GOOD; } else judge_num= JUDGE::BAD; }
void C4FacetEx::DrawBolt(int iX1, int iY1, int iX2, int iY2, BYTE bCol, BYTE bCol2) { if (!lpDDraw || !Surface || !Wdt || !Hgt) return; // Scroll position iX1 -= TargetX; iY1 -= TargetY; iX2 -= TargetX; iY2 -= TargetY; // Facet bounds if (!Inside(iX1, 0, Wdt - 1) && !Inside(iX2, 0, Wdt - 1)) return; if (!Inside(iY1, 0, Hgt - 1) && !Inside(iY2, 0, Hgt - 1)) return; iX1 += X; iX2 += X; iY1 += Y; iY2 += Y; // Draw bolt int pvtx[2 * 4]; pvtx[0] = iX1; pvtx[1] = iY1; pvtx[2] = iX2; pvtx[3] = iY2; #ifdef C4ENGINE pvtx[4] = iX2 + SafeRandom(DrawBoltR1) - DrawBoltR2; pvtx[5] = iY2 + SafeRandom(DrawBoltR1) - DrawBoltR2; pvtx[6] = iX1 + SafeRandom(DrawBoltR1) - DrawBoltR2; pvtx[7] = iY1 + SafeRandom(DrawBoltR1) - DrawBoltR2; #else pvtx[4] = iX2 + X % 3 - 1; pvtx[5] = iY2 + X % 3 - 1; pvtx[6] = iX1 + Y % 3 - 1; pvtx[7] = iY1 + Y % 3 - 1; #endif // Draw in surface DWORD dwClr1 = lpDDraw->Pal.GetClr(bCol), dwClr2; DWORD dwClr3 = lpDDraw->Pal.GetClr(bCol2), dwClr4; /*if (DDrawCfg.NoBoxFades) {*/ dwClr2 = dwClr1; dwClr4 = dwClr3; /*} else { DWORD dwClr2=dwClr1|0xff000000; ...this leads to black and white lightning bolts. Who wants that? DWORD dwClr4=dwClr3|0xff000000; }*/ lpDDraw->DrawQuadDw(Surface, pvtx, dwClr1, dwClr3, dwClr4, dwClr2); }
func Intro_Stop() { // Lava gets quiet after intro var lava = FindObject(Find_ID(BoilingLava)); if (lava) lava->SetIntensity(25); // if players got stuck somewhere, unstick them for (var i=0; i<GetPlayerCount(C4PT_User); ++i) { var plr = GetPlayerByIndex(i, C4PT_User); var crew = GetCrew(plr); if (crew && !Inside(crew->GetX(),125,170)) { crew->SetPosition(135+Random(25), 860); } crew->Extinguish(); crew->DoEnergy(100); } this.dialogue->SetInteraction(true); this.dialogue->AddAttention(); SetPlayerZoomByViewRange(NO_OWNER, 400,300, PLRZOOM_Set); // Turn and relocate the airplane to make starting it easier. var plane = FindObject(Find_ID(Airplane)); if (plane) { plane->FaceLeft(); plane->SetR(-90); plane->SetPosition(1387, 345); } return true; }
bool C4MapScriptAlgoPolygon::operator () (int32_t x, int32_t y, uint8_t& fg, uint8_t& bg) const { // Evaluate MAPALGO_Polygon at x,y: Return 1 for pixels within the polygon or its borders, 0 otherwise int32_t crossings = 0; for (size_t i=0; i<poly.size(); ++i) { Pt pt1 = poly[i]; Pt pt2 = poly[(i+1)%poly.size()]; // check border line distance int32_t pdx = pt2.x-pt1.x, pdy = pt2.y-pt1.y, dx = x-pt1.x, dy = y-pt1.y; if (i!=poly.size()-1 || !open) { int64_t d = dx*pdy-dy*pdx; int32_t lsq = (pdx*pdx+pdy*pdy); if (d*d < wdt*wdt*lsq) // check distance perpendicular to line { if (Inside(dx*pdx+dy*pdy, 0, lsq)) // check if point lies within pt1 and pt2 return true; // x/y lies on this line } } // check point distance if (dx*dx+dy*dy < wdt*wdt) return true; // x/y lies close to edge point // filling of polygon: point is contained if it crosses an off number of borders if (!empty && (pt1.y<=y) != (pt2.y<=y)) // crossing vertically? { // does line pt1-pt2 intersect line (x,y)-(inf,y)? crossings += (dx>dy*pdx/pdy); } } // x/y lies inside polygon return (crossings % 2)==1; }
vector<int> Floor::ComputeShortestPath(int start, int end) const { int cur = start; vector<int> moves; while (cur != end) { int move = 0; double cur_dist = Distance(cur, end); if (cur_dist == NumCells()) { return moves; } for (int a = 0; a < 4; a++) { Coord pos = GetCell(cur) + Compass::DIRECTIONS[a]; int next = cur; if (Inside(pos)) next = GetIndex(pos); double dist = Distance(next, end); if (dist < cur_dist) { move = a; cur = next; break; } } moves.push_back(move); } return moves; }
private func FitsInElevator(pObject) { // Fahrzeuge, die eine Extra Aufzugsaktion haben, sollten immer passen if(pObject->~FitsInElevator()) return(1);//ObjectSetAction(pObject, "Elevator")) return(1); // Alle (ungedrehten) Vertices des Objekts prüfen var vertexCount = GetDefCoreVal("Vertices", "DefCore", pObject->GetID()); for (var i = 0; i < vertexCount; i++) { var vertexX = GetDefCoreVal("VertexX", "DefCore", pObject->GetID(), i); var vertexY = GetDefCoreVal("VertexY", "DefCore", pObject->GetID(), i); // Passt nicht if (!Inside(vertexX, -12, 11) || !Inside(vertexY, -20, 16)) return(0); } // Passt return(1); }
C4Graph::ValueType C4TableGraph::GetValue(TimeType iAtTime) const { // must be inside buffer assert(Inside(iAtTime, GetStartTime(), GetEndTime() - 1)); // query it - can't be negative if inside start/end-time return pAveragedValues[(iAtTime - iInitialStartTime) % iBackLogLength] * fMultiplier; }
const typename Inside::member_type& get() { auto _this = Outside(this->t); auto get_this = _this.get(); auto get_that = Inside(get_this); return get_that.get(); }
int TextArea::MouseMove( float x, float y ) { if (do_highlight == 0) return 0; if (Inside( x, y, 5 ) == 0) return 0; cur_highlighted = LocateCount( y ); return 1; }
int TextArea::MouseMoveClick( float x, float y ) { if (scroll_start == 0 && Inside( x, y, 4 ) == 0) return 0; if (scroll_start == 0) scroll_start = y; scroll_cur = y; return 1; }
bool AbstractAirspace::Inside(const AircraftState &state) const { return altitude_base.IsBelow(state) && altitude_top.IsAbove(state) && Inside(state.location); }
bool TCheckbox::Click(int state, int x, int y) { if (active && visible && Inside(x, y, mouseRect)) { if (state) checked = !checked; return true; } return false; }
//##################################################################### // Function Calculate_Signed_Distance //##################################################################### template<class T> T POINT_SIMPLICES_1D<T>:: Calculate_Signed_Distance(const TV& location,T thickness_over_two) const { T distance; Closest_Point_On_Boundary(location,0,thickness_over_two,0,&distance); if(Inside(location,thickness_over_two)) distance*=-1; return distance; }
const typename Outside::object_type set(const typename Inside::member_type& a) { auto _this = Outside(this->t); auto get_this = _this.get(); auto mod_that = Inside(get_this).set(a); return _this.set(mod_that); }
/* * Implementation of the clipping algortihim * outputVertexes - The vertexes that will be output inputVertacies - The vertacies passed into the algorithim Edge - The edge we are clipping on */ void clipper::ClipSide(std::vector<EnumTypes::Vertex>* outputVertexes, std::vector<EnumTypes::Vertex> inputVertacies, EnumTypes::Line* Edge) { //Each interation update the start vertex, end, and intersection of the given bvetacie and the edge EnumTypes::Vertex start, end, intersection; //Get the last vertacie if (inputVertacies.size() != 0) { start = inputVertacies.at(inputVertacies.size() - 1); } //Loop through all of the input vertacies for (int x = 0; x < inputVertacies.size(); x++) { end = inputVertacies.at(x); //If the start point is inside if (Inside(end, *Edge)) { if (Inside(start, *Edge)) { addVertexOutput(&end, outputVertexes); } else { EnumTypes::Line *tLine = new EnumTypes::Line(&start, &end, true); Intersect(*tLine, *Edge, &intersection); delete tLine; addVertexOutput(&intersection, outputVertexes); addVertexOutput(&end, outputVertexes); } } else { if (Inside(start, *Edge)) { EnumTypes::Line *tLine = new EnumTypes::Line(&start, &end, true); Intersect(*tLine, *Edge, &intersection); delete tLine; addVertexOutput(&intersection, outputVertexes); } } start = end; } }
Block* Block::GetBlock(const dReal* AABB){ if (Inside(AABB)){ return GetBlockChild(AABB); // Child or this will have a good block } else if (Parent){ return Parent->GetBlock(AABB); // Parent has a good block } else return this; // We are at the root, so we have little choice }
void Slider::Handle (Event& e) { if (e.eventType == DownEvent) { if (Inside(e)) { Slide(e); } else { Jump(e); } interactor->Adjust(*shown); } }
Clik cCaseX11Xml::clik_in() { while (1) { Clik aClk = mW.clik_in(); if (Inside(Pt2di(aClk._pt))) return aClk; } return mW.clik_in(); }
private func CheckStuck() { var pClonk,iYChange,iX,iY; // Alle feststeckenden Clonks in der Nähe suchen for (pClonk in FindObjects(Find_InRect(-20,-20,40,40), Find_OCF(OCF_CrewMember),Find_NoContainer())) { iX=GetX(pClonk); iY=GetY(pClonk); while(Stuck(pClonk) && Inside(GetY(pClonk)-GetY(),-20,20)) { if(!(iYChange=BoundBy(GetY(pClonk)-GetY(),-1,1))) iYChange=1; // Zur Sicherheit... if(!Inside(GetY(pClonk)+iYChange,-100,LandscapeHeight())) break; SetPosition(GetX(pClonk),GetY(pClonk)+iYChange,pClonk); } // verschieben fehlgeschlagen: rückgängig machen if(Stuck(pClonk)) SetPosition(iX,iY,pClonk); } }
void C4GameSaveSavegame::AdjustCore(C4Scenario &rC4S) { // Determine save game index from trailing number in group file name int iSaveGameIndex = GetTrailingNumber(GetFilenameOnly(pSaveGroup->GetFullName().getData())); // Looks like a decent index: set numbered icon if (Inside(iSaveGameIndex, 1, 10)) rC4S.Head.Icon = 2 + (iSaveGameIndex - 1); // Else: set normal script icon else rC4S.Head.Icon = 29; }
Spectrum ProjectionLight::Projection(const Vector3f &w) const { Vector3f wl = WorldToLight(w); // Discard directions behind projection light if (wl.z < hither) return 0; // Project point onto projection plane and compute light Point3f p = lightProjection(Point3f(wl.x, wl.y, wl.z)); if (!Inside(Point2f(p.x, p.y), screenBounds)) return 0.f; if (!projectionMap) return 1; Point2f st = Point2f(screenBounds.Offset(Point2f(p.x, p.y))); return Spectrum(projectionMap->Lookup(st), SpectrumType::Illuminant); }
void CAIVolume::EnumerateSearchNodes(uint32* aiSearchNodes, uint32* pcSearchNodes, const uint32 nMaxSearchNodes) const { for ( uint32 iNode = 0 ; iNode < g_pAINodeMgr->GetNumNodes() && *pcSearchNodes < nMaxSearchNodes ; iNode++ ) { CAINode* pNode = g_pAINodeMgr->GetNode(iNode); if ( pNode && pNode->IsSearchable() && Inside(pNode->GetPos(), 53.0f) ) { aiSearchNodes[(*pcSearchNodes)++] = pNode->GetID(); } } }
bool TIconButton::Click(int state, int x, int y) { if (Inside(x, y, mouseRect)) { focus = true; if (state) { value++; if (value > maximum) value = 0; } return true; } return false; }
inline bool Inside( const AABB &bbox ) { if ( !Inside( bbox.m_Center ) ) return false; for ( int i = 0; i < 3; i++ ) { if ( m_MaxCorner[ i ] < bbox.m_MaxCorner[ i ] ) return false; if ( bbox.m_MinCorner[ i ] > m_MinCorner[ i ] ) return false; } return true; }
bool ClrByOwner(DWORD &dwClr) // new style, based on Microsoft Knowledge Base Article - 29240 { int H,L,S; WORD R,G,B; BYTE cMax,cMin; WORD Rdelta,Gdelta,Bdelta; // get RGB R = GetRedValue(dwClr); G = GetGreenValue(dwClr); B = GetBlueValue(dwClr); // calculate lightness cMax = std::max<int>(std::max<int>(R,G),B); cMin = std::min<int>(std::min<int>(R,G),B); L = ( ((cMax+cMin)*HLSMAX) + RGBMAX )/(2*RGBMAX); // achromatic case if (cMax == cMin) { S = 0; H = (HLSMAX*2/3); } // chromatic case else { // saturation if (L <= (HLSMAX/2)) S = ( ((cMax-cMin)*HLSMAX) + ((cMax+cMin)/2) ) / (cMax+cMin); else S = ( ((cMax-cMin)*HLSMAX) + ((2*RGBMAX-cMax-cMin)/2) ) / (2*RGBMAX-cMax-cMin); // hue Rdelta = ( ((cMax-R)*(HLSMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin); Gdelta = ( ((cMax-G)*(HLSMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin); Bdelta = ( ((cMax-B)*(HLSMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin); if (R == cMax) H = Bdelta - Gdelta; else if (G == cMax) H = (HLSMAX/3) + Rdelta - Bdelta; else H = ((2*HLSMAX)/3) + Gdelta - Rdelta; if (H < 0) H += HLSMAX; if (H > HLSMAX) H -= HLSMAX; } // Not blue if (!(Inside(H, 145, 175) && (S > 100))) return false; // It's blue: make it gray BYTE b = GetBlueValue(dwClr); dwClr = RGBA(b, b, b, 0) | (dwClr & 0xff000000); return true; }