void Player::onUpdate(float frametime) { static const EntityManager& manager = EntityManager::getInstance(); // Animation m_animator.updateSubRect(*this, frametime); // Weapons if (!m_overheat) { float h = 0.f; if (Input::isPressed(Action::USE_LASER)) { h += m_weapon.shoot(0); } m_heat += h; if (m_heat >= m_max_heat) { m_overheat = true; m_panel.setOverheat(true); MessageSystem::write(_t("panel.overheat"), getPosition()); } if (h > 0) overheatAudioHint(); } // Compute position sf::Vector2f pos = getPosition(); float delta = m_speed * frametime; if (Input::isPressed(Action::UP)) pos.y -= delta; if (Input::isPressed(Action::DOWN)) pos.y += delta; if (Input::isPressed(Action::LEFT)) pos.x -= delta; if (Input::isPressed(Action::RIGHT)) pos.x += delta; // Ensure new position is within screen's limits const int X_BOUND = manager.getWidth() - getWidth(); const int Y_BOUND = manager.getHeight() - getHeight(); if (pos.y < 0) pos.y = 0; else if (pos.y > Y_BOUND) pos.y = Y_BOUND; if (pos.x < 0) pos.x = 0; else if (pos.x > X_BOUND) pos.x = X_BOUND; // Apply new position setPosition(pos); m_smoke_emitter.setPosition(getX(), getY() + getHeight() / 2); m_shield_emitter.setPosition(getCenter()); // Cooling heatsink if (m_heat > 0.f) { m_heat -= frametime * m_max_heat / COOLING_DELAY; if (m_heat <= 0.f) { m_heat = 0.f; if (m_overheat ) { m_overheat = false; m_panel.setOverheat(false); } } } m_panel.setHeat(m_heat); // Decrase powerups timers for (int i = 0; i < TIMED_BONUS_COUNT; ++i) { if (bonus_[i] > 0) { bonus_[i] -= frametime; if (bonus_[i] <= 0) { bonus_[i] = 0; DisableTimedPowerUp((TimedPowerUp) i); } } } updateDamageFlash(frametime); }
void Polygon::sort() { AngleXYComparator angleXYComparator(getCenter()); std::sort(m_listOfVertices.begin(), m_listOfVertices.end(), angleXYComparator); }
const Vec3f Box3f::getClosestPoint( const Vec3f& point ) { Vec3f result; // trivial cases first if ( isEmpty() ) { return point; } else if (point == getCenter()) { // middle of z side result[0] = (m_max[0] + m_min[0])/2.0f; result[1] = (m_max[1] + m_min[1])/2.0f; result[2] = m_max[2]; } else { // Find the closest point on a unit box (from -1 to 1), // then scale up. // Find the vector from center to the point, then scale // to a unit box. Vec3f vec = point - getCenter(); float sizeX, sizeY, sizeZ; getSize(sizeX, sizeY, sizeZ); float halfX = sizeX/2.0f; float halfY = sizeY/2.0f; float halfZ = sizeZ/2.0f; if (halfX > 0.0) vec[0] /= halfX; if (halfY > 0.0) vec[1] /= halfY; if (halfZ > 0.0) vec[2] /= halfZ; // Side to snap side that has greatest magnitude in the vector. Vec3f mag; mag[0] = fabs(vec[0]); mag[1] = fabs(vec[1]); mag[2] = fabs(vec[2]); result = mag; // Check if beyond corners if (result[0] > 1.0) result[0] = 1.0; if (result[1] > 1.0) result[1] = 1.0; if (result[2] > 1.0) result[2] = 1.0; // snap to appropriate side if ((mag[0] > mag[1]) && (mag[0] > mag[2])) { result[0] = 1.0; } else if ((mag[1] > mag[0]) && (mag[1] > mag[2])) { result[1] = 1.0; } else if ((mag[2] > mag[0]) && (mag[2] > mag[1])) { result[2] = 1.0; } else if ((mag[0] == mag[1]) && (mag[0] == mag[2])) { // corner result = Vec3f(1,1,1); } else if (mag[0] == mag[1]) { // edge parallel with z result[0] = 1.0; result[1] = 1.0; } else if (mag[0] == mag[2]) { // edge parallel with y result[0] = 1.0; result[2] = 1.0; } else if (mag[1] == mag[2]) { // edge parallel with x result[1] = 1.0; result[2] = 1.0; } else { assert( false ); // Can't determine vector to point. } // Now make everything point the right way for (int32 i=0; i < 3; i++) { if (vec[i] < 0.0) result[i] = -result[i]; } // scale back up and move to center result[0] *= halfX; result[1] *= halfY; result[2] *= halfZ; result += getCenter(); } return result; }
void MgBaseRect::setCenter(const Point2d& pt) { Point2d old = getCenter(); for (int i = 0; i < 4; i++) _points[i].offset(pt.x - old.x, pt.y - old.y); }
kmVec3 BoundingBox::getCenter() const { kmVec3 center = vec3Zero; getCenter(¢er); return center; }
bool BF3PointCircle::getRobustCircle(const BFContour& contour, const unsigned int maxVotes, const unsigned int maxAccu, const int maxInvalidVotesInSeries, BFCircle& circle) { unsigned int nContourPoints = contour.getPixelCount(); BFRectangle rect = contour.getBounds(); BFRectangle zeroRect; if(rect.equals(zeroRect)) { return false; } int nRows = bfRound(rect.getHeight()); int nCols = bfRound(rect.getWidth()); int x0 = bfRound(rect.getX0()); int y0 = bfRound(rect.getY0()); BFCoordinate<int> topLeft(x0,y0); int invalidVotesInSeries = 0; // generate 2d histogram for circle center estimation Eigen::MatrixXi H = Eigen::MatrixXi::Zero(nRows, nCols); unsigned int votes = 0; for(votes; votes <= maxVotes; ++votes) { // random index number in range [0,nContourPoints-1] unsigned int randIndex1 = (rand() % nContourPoints); unsigned int randIndex2 = (rand() % nContourPoints); while(randIndex2 == randIndex1) randIndex2 = (rand() % nContourPoints); unsigned int randIndex3 = (rand() % nContourPoints); while(randIndex3 == randIndex2 || randIndex3 == randIndex1) randIndex3 = (rand() % nContourPoints); BFCoordinate<int> c1 = contour.getCoordinate(randIndex1) - topLeft; BFCoordinate<int> c2 = contour.getCoordinate(randIndex2) - topLeft; BFCoordinate<int> c3 = contour.getCoordinate(randIndex3) - topLeft; BFCoordinate<double> center; bool validCenter = getCenter(c1,c2,c3,center); if(!validCenter) { votes--; invalidVotesInSeries++; if(invalidVotesInSeries > maxInvalidVotesInSeries) { return false; } continue; } invalidVotesInSeries = 0; double cxD = center.getX(); double cyD = center.getY(); int cx = bfRound(cxD); int cy = bfRound(cyD); if(cx < 0 || cy < 0 || cx >= nRows || cy >= nCols) { votes--; continue; } else { H(cx,cy) += 1; if(H(cx,cy) >= static_cast<int>(maxAccu)) { break; } } } int finalX = 0; int finalY = 0; H.maxCoeff(&finalX,&finalY); finalX += bfRound(x0); finalY += bfRound(y0); // generate 1d histogram for circle radius estimation Eigen::VectorXi K = Eigen::VectorXi::Zero(bfMax(nRows,nCols)); const std::vector<BFCoordinate<int> >& cont = contour.getContour(); std::vector<BFCoordinate<int> >::const_iterator iter = cont.begin(); int x; int y; while(iter != cont.end()) { x = bfRound((*iter).getX()); y = bfRound((*iter).getY()); int r = bfRound(sqrt(pow(static_cast<double>(x-finalX),2) + pow(static_cast<double>(y-finalY),2))); if(r < K.rows()) { K(r) += 1; } iter++; } int finalR = 0; K.maxCoeff(&finalR); // return result circle.set(finalX,finalY,finalR); return true; }
/* POSITION 0: ROTATE RIGHT POSITION 1: ROTATE LEFT POSITION 2: MOVE UP POSITION 3: MOVE DOWN POSITION 4: JUMP */ double NPC::movementEvaluate(vector<int> individual,int size_vector) { srand(time(NULL)); Stadium* stadium = NPC::stadium; Circle *c = stadium->getLimiteExterior(); double playerX = player->getX(); double playerY = player->getY(); double score = 0; double afterAngle = 0; // double angle = atan2(playerY, playerX ) - atan2(getCoord_y(), getCoord_y()); double afterX = getCenter()->getX(); double afterY = getCenter()->getY(); double current_distance = player->distance2D(afterX,afterY); // if(individual[0] == 1) // { // afterAngle = getAfterPersonAngle(1,0); // // score +=4; // score++; // } // if(individual[1] == 1) // { // afterAngle = getAfterPersonAngle(0,1); // score++; // } if(individual[2] == 1) { // afterX = getAfterX(1,0); // afterY = getAfterY(1,0); score += 3; // score++; } if(individual[3] == 1) { // afterX = getAfterX(-1,afterAngle); // afterY = getAfterY(-1,afterAngle); // score += 2; score++; } // // if(individual[4] == 1) // // { // // if(stadium->inObstacle(afterX, afterY, getRadius() && !stadium->inObstacle(getCenter()->getX(),getCenter()->getY() , getRadius() ))) // // { // // score += 30; // // }else{ // // score -=2; // // } // // score--; // // } double x,y; simulateLook(afterX,afterY, afterAngle, x,y); // if(!stadium->isValidMoveNPC(this,afterX,afterY)) // { // score -= 999999; // }else // double norma = atan2(playerY, playerX ) - atan2(afterY, afterX) * getRadius() / current_distance; double norma = player->distance2D(afterX,afterY) / current_distance; if(norma < 1) { score += (1 - norma)*3; } // cout << afterX << ":"<<afterY<< ":"<< score<<endl; score += ((double) rand() / (RAND_MAX)) + 1; return score; }
void TextBlock::draw(){ float yAlig = y; if (vAlignment == OF_TEXT_ALIGN_BOTTOM){ yAlig = y + height - getTextHeight(); } else if (vAlignment == OF_TEXT_ALIGN_MIDDLE){ yAlig = getCenter().y - getTextHeight()*0.5; } if (hAlignment == OF_TEXT_ALIGN_LEFT){ string strToDraw; int currentWordID; float drawX; float drawY; float currX = 0; if (words.size() > 0){ for(int l=0;l < lines.size(); l++){ for(int w=0;w < lines[l].wordsID.size(); w++){ currentWordID = lines[l].wordsID[w]; drawX = x + currX; drawY = yAlig + (font->getLineHeight() * (l + 1)); ofPushMatrix(); font->drawString(words[currentWordID].rawWord.c_str(), drawX, drawY); currX += words[currentWordID].width; ofPopMatrix(); } currX = 0; } } } else if (hAlignment == OF_TEXT_ALIGN_RIGHT){ string strToDraw; int currentWordID; float drawX; float drawY; float currX = 0; if (words.size() > 0) { for(int l=0;l < lines.size(); l++){ for(int w=lines[l].wordsID.size() - 1; w >= 0; w--){ currentWordID = lines[l].wordsID[w]; drawX = -currX - words[currentWordID].width; drawY = font->getLineHeight() * (l + 1); ofPushMatrix(); //Move to top left point using pre-scaled co-ordinates ofTranslate(x + width, yAlig, 0.0f); font->drawString(words[currentWordID].rawWord.c_str(), drawX, drawY); currX += words[currentWordID].width; ofPopMatrix(); } currX = 0; } } } else if (hAlignment == OF_TEXT_ALIGN_JUSTIFIED){ string strToDraw; int currentWordID; float drawX; float drawY; int spacesN; float nonSpaceWordWidth; float pixelsPerSpace; float currX = 0; if (words.size() > 0) { for(int l=0;l < lines.size(); l++){ //Find number of spaces and width of other words; spacesN = 0; nonSpaceWordWidth = 0; for(int w = 0; w < lines[l].wordsID.size(); w++){ currentWordID = lines[l].wordsID[w]; if (words[currentWordID].rawWord == " ") spacesN++; else nonSpaceWordWidth += words[currentWordID].width; } pixelsPerSpace = (width - x - nonSpaceWordWidth) / spacesN; for(int w=0;w < lines[l].wordsID.size(); w++){ currentWordID = lines[l].wordsID[w]; drawX = currX; drawY = font->getLineHeight() * (l + 1); ofPushMatrix(); //Move to top left point using pre-scaled co-ordinates ofTranslate(x, yAlig, 0.0f); if (words[currentWordID].rawWord != " ") { font->drawString(words[currentWordID].rawWord.c_str(), drawX, drawY); currX += words[currentWordID].width; } else { currX += pixelsPerSpace; } ofPopMatrix(); } currX = 0; } } } else if (hAlignment == OF_TEXT_ALIGN_CENTER ){ string strToDraw; int currentWordID; float drawX; float drawY; float lineWidth; float currX = 0; if (words.size() > 0) { for(int l=0;l < lines.size(); l++){ //Get the length of the line. lineWidth = 0; for(int w=0;w < lines[l].wordsID.size(); w++){ currentWordID = lines[l].wordsID[w]; lineWidth += words[currentWordID].width; } for(int w=0;w < lines[l].wordsID.size(); w++){ currentWordID = lines[l].wordsID[w]; drawX = -(lineWidth / 2) + currX; drawY = font->getLineHeight() * (l + 1); ofPushMatrix(); //Move to central point using pre-scaled co-ordinates ofTranslate(getCenter().x, yAlig, 0.0f); font->drawString(words[currentWordID].rawWord.c_str(), drawX, drawY); currX += words[currentWordID].width; ofPopMatrix(); } currX = 0; } } } }
AnnularRegion::AnnularRegion(const MinorCircleRegion &mcr, Radian w) : MinorCircleRegion(mcr), width(w) { // Make a second MCR with a smaller radius inner = new MinorCircleRegion( getCenter(), getRadius() - w ); }
Cube Cube::boundingBox() { return Cube(getMin(),getMax(),getCenter()); }
Scalar radius() const { return (getCenter() - min).norm(); }
QList<QSharedPointer<RShape> > RDimAngularData::getShapes(const RBox& queryBox, bool ignoreComplex, bool segment) const { Q_UNUSED(queryBox) Q_UNUSED(ignoreComplex) Q_UNUSED(segment) QSharedPointer<RBlockReferenceEntity> dimBlockReference = getDimensionBlockReference(); if (!dimBlockReference.isNull()) { return dimBlockReference->getShapes(queryBox, ignoreComplex); } QList<QSharedPointer<RShape> > ret; double dimexo = getDimexo(); double dimexe = getDimexe(); double dimtxt = getDimtxt(); double dimgap = getDimgap(); double dimasz = getDimasz(); // find out center: RVector center = getCenter(); if (!center.isValid()) { return ret; } double ang1 = 0.0; double ang2 = 0.0; bool reversed = false; RVector p1; RVector p2; getAngles(ang1, ang2, reversed, p1, p2); double rad = dimArcPosition.getDistanceTo(center); RLine line; RVector dir; double len; double dist; // 1st extension line: dist = center.getDistanceTo2D(p1); len = rad - dist + dimexe; dir.setPolar(1.0, ang1); line = RLine(center + dir*dist + dir*dimexo, center + dir*dist + dir*len); ret.append(QSharedPointer<RShape>(new RLine(line))); // 2nd extension line: dist = center.getDistanceTo2D(p2); len = rad - dist + dimexe; dir.setPolar(1.0, ang2); line = RLine(center + dir*dist + dir*dimexo, center + dir*dist + dir*len); ret.append(QSharedPointer<RShape>(new RLine(line))); // Create dimension line (arc): RArc arc(center, rad, ang1, ang2, reversed); ret.append(QSharedPointer<RShape>(new RArc(arc))); // length of dimension arc: double distance = arc.getLength(); // do we have to put the arrows outside of the arc? bool outsideArrows = (distance<dimasz*2); // arrow angles: double arrowAngle1, arrowAngle2; double arrowAng; if (rad>1.0e-6) { arrowAng = getDimasz() / rad; } else { arrowAng = 0.0; } if (outsideArrows) { arrowAngle1 = arc.getDirection1(); arrowAngle2 = arc.getDirection2(); } else { RVector v1, v2; if (!arc.isReversed()) { v1.setPolar(rad, arc.getStartAngle()+arrowAng); } else { v1.setPolar(rad, arc.getStartAngle()-arrowAng); } v1+=arc.getCenter(); arrowAngle1 = arc.getStartPoint().getAngleTo(v1); if (!arc.isReversed()) { v2.setPolar(rad, arc.getEndAngle()-arrowAng); } else { v2.setPolar(rad, arc.getEndAngle()+arrowAng); } v2+=arc.getCenter(); arrowAngle2 = arc.getEndPoint().getAngleTo(v2); arrowAngle1 = arrowAngle1+M_PI; arrowAngle2 = arrowAngle2+M_PI; } // Arrows: //RTriangle arrow = RTriangle::createArrow(arc.getStartPoint(), arrowAngle1, dimasz); QList<QSharedPointer<RShape> > arrow = getArrow(arc.getStartPoint(), arrowAngle1); ret.append(arrow); //arrow = RTriangle::createArrow(arc.getEndPoint(), arrowAngle2, dimasz); arrow = getArrow(arc.getEndPoint(), arrowAngle2); ret.append(arrow); //ret.append(QSharedPointer<RShape>(new RTriangle(arrow))); //RVector oldMot = textPosition; //textPosition = RVector(0,0); //defaultAngle = 0.0; //dimLineLength = RNANDOUBLE; //getTextData(); //textPosition = oldMot; RVector textPos = arc.getMiddlePoint(); double dimAngle1 = textPos.getAngleTo(arc.getCenter())-M_PI/2.0; if (!autoTextPos) { dimAngle1 = textPositionCenter.getAngleTo(arc.getCenter())-M_PI/2.0; } RVector distV; double textAngle; // rotate text so it's readable from the bottom or right (ISO) // quadrant 1 & 4 if (dimAngle1>M_PI/2.0*3.0+0.001 || dimAngle1<M_PI/2.0+0.001) { distV.setPolar(dimgap + dimtxt/2, dimAngle1+M_PI/2.0); textAngle = dimAngle1; } // quadrant 2 & 3 else { distV.setPolar(dimgap + dimtxt/2, dimAngle1-M_PI/2.0); textAngle = dimAngle1+M_PI; } if (!autoTextPos) { textPos = textPositionCenter; } else { // move text away from dimension line: textPos+=distV; textPositionCenter = textPos; } defaultAngle = textAngle; //getTextData(); //textData.rotate(textAngle, RVector(0,0)); //textData.move(textPos); return ret; }
void bulletClass::applyMove() { oldCenter = getCenter(); sprite.move(velocity); }
void Player::onCollision(PowerUp& powerup) { switch (powerup.getType()) { // timed bonus case PowerUp::DOUBLE_SHOT: if (bonus_[T_DOUBLESHOT] == 0) m_weapon.setMultiply(2); bonus_[T_TRISHOT] = 0; bonus_[T_DOUBLESHOT] += TIMED_BONUS_DURATION; m_panel.activeAttackPowerUp(bonus_[T_DOUBLESHOT], powerup.getType()); break; case PowerUp::TRIPLE_SHOT: if (bonus_[T_TRISHOT] == 0) m_weapon.setMultiply(3); bonus_[T_DOUBLESHOT] = 0; bonus_[T_TRISHOT] += TIMED_BONUS_DURATION; m_panel.activeAttackPowerUp(bonus_[T_TRISHOT], powerup.getType()); break; case PowerUp::SPEED: if (bonus_[T_SPEED] == 0) { m_speed *= BONUS_SPEED_FACTOR; m_smoke_emitter.createParticles(120); } bonus_[T_SPEED] += TIMED_BONUS_DURATION; m_panel.activeSpeedPowerUp(bonus_[T_SPEED]); break; // immediate bonus case PowerUp::REPAIR: if (getHP() < m_max_hp) m_panel.setHP(updateHP(1)); break; case PowerUp::FULL_REPAIR: setHP(m_max_hp); m_panel.setHP(m_max_hp); m_powerup_emitter.setPosition(getCenter()); m_powerup_emitter.createParticles(50); break; case PowerUp::SHIELD: if (m_shield < m_max_shield) setShield(m_shield + 1); break; case PowerUp::FULL_SHIELD: setShield(m_max_shield); m_panel.setShield(m_max_shield); m_powerup_emitter.setPosition(getCenter()); m_powerup_emitter.createParticles(50); break; case PowerUp::ICECUBE: if (m_icecubes < MAX_ICECUBES) m_panel.setIcecubes(++m_icecubes); break; case PowerUp::MISSILE: if (m_missiles < MAX_MISSILES) m_panel.setMissiles(++m_missiles); break; default: break; } powerup.kill(); MessageSystem::write(powerup.getDescription(), powerup.getPosition()); SoundSystem::playSound("power-up.ogg"); }
bool BoundingBox::overlapsWith(const BoundingBox& other) { if(!use || !other.use) return false; float wa = getWidth()/2; float ha = getHeight()/2; float da = getDepth()/2; glm::vec3 Ca = getCenter(); glm::vec3 Az = getFrontNormal(); glm::vec3 Ay = getUpNormal(); glm::vec3 Ax = getRightNormal(); glm::vec3 Cb = other.getCenter(); glm::vec3 Bz = other.getFrontNormal(); glm::vec3 By = other.getUpNormal(); glm::vec3 Bx = other.getRightNormal(); float wb = other.getWidth()/2; float hb = other.getHeight()/2; float db = other.getDepth()/2; glm::vec3 T = Cb - Ca; float lhs = 0, rhs = 0; float Rxx = glm::dot(Ax, Bx); float Rxy = glm::dot(Ax, By); float Rxz = glm::dot(Ax, Bz); // Case 1: L = Ax lhs = glm::dot(T, Ax); rhs = wa + fabs(wb * Rxx) + fabs(hb * Rxy) + fabs(db * Rxz); if(lhs > rhs) return false; float Ryx = glm::dot(Ay, Bx); float Ryy = glm::dot(Ay, By); float Ryz = glm::dot(Ay, Bz); // Case 2: L = Ay lhs = glm::dot(T, Ay); rhs = ha + fabs(wb * Ryx) + fabs(hb * Ryy) + fabs(db * Ryz); if(lhs > rhs) return false; float Rzx = glm::dot(Az, Bx); float Rzy = glm::dot(Az, By); float Rzz = glm::dot(Az, Bz); // Case 3: L = Az lhs = glm::dot(T, Az); rhs = da + fabs(wb * Rzx) + fabs(hb * Rzy) + fabs(db * Rzz); if(lhs > rhs) return false; // Case 4: L = Bx lhs = glm::dot(T, Bx); rhs = fabs(wa * Rxx) + fabs(ha * Ryx) + fabs(da * Rzx) + wb; if(lhs > rhs) return false; // Case 5: L = By lhs = glm::dot(T, By); rhs = fabs(wa * Rxy) + fabs(ha * Ryy) + fabs(da * Rzy) + hb; if(lhs > rhs) return false; // Case 6: L = Bz lhs = glm::dot(T, Bz); rhs = fabs(wa * Rxz) + fabs(ha * Ryz) + fabs(da * Rzz) + db; if(lhs > rhs) return false; // Case 7: L = Ax x Bx lhs = glm::dot(T, glm::cross(Ax, Bx)); rhs = fabs(ha * Rzx) + fabs(da * Ryx) + fabs(hb * Rxz) + fabs(db * Rxy); if(lhs > rhs) return false; // Case 8: L = Ax x By lhs = glm::dot(T, glm::cross(Ax, By)); rhs = fabs(ha * Rzy) + fabs(da * Ryy) + fabs(wb * Rxz) + fabs(db * Rxx); if(lhs > rhs) return false; // Case 9: L = Ax x Bz lhs = glm::dot(T, glm::cross(Ax, Bz)); rhs = fabs(ha * Rzz) + fabs(da * Ryz) + fabs(wb * Rxy) + fabs(hb * Rxx); if(lhs > rhs) return false; // Case 10: L = Ay x Bx lhs = glm::dot(T, glm::cross(Ay, Bx)); rhs = fabs(wa * Rzx) + fabs(da * Rxx) + fabs(hb * Ryz) + fabs(db * Ryy); if(lhs > rhs) return false; // Case 11: L = Ay x By lhs = glm::dot(T, glm::cross(Ay, By)); rhs = fabs(wa * Rzy) + fabs(da * Rxy) + fabs(wb * Ryz) + fabs(db * Ryx); if(lhs > rhs) return false; // Case 12: L = Ay x Bz lhs = glm::dot(T, glm::cross(Ay, Bz)); rhs = fabs(wa * Rzz) + fabs(da * Rxz) + fabs(wb * Ryy) + fabs(hb * Ryx); if(lhs > rhs) return false; // Case 13: L = Az x Bx lhs = glm::dot(T, glm::cross(Az, Bx)); rhs = fabs(wa * Ryx) + fabs(ha * Rxx) + fabs(hb * Rzz) + fabs(db * Rzy); if(lhs > rhs) return false; // Case 14: L = Az x By lhs = glm::dot(T, glm::cross(Az, By)); rhs = fabs(wa * Ryy) + fabs(ha * Rxy) + fabs(wb * Rzz) + fabs(db * Rzx); if(lhs > rhs) return false; // Case 15: L = Az x Bz lhs = glm::dot(T, glm::cross(Az, Bz)); rhs = fabs(wa * Ryz) + fabs(ha * Rxz) + fabs(wb * Rzy) + fabs(hb * Rzx); if(lhs > rhs) return false; return true; }
void CloudsHUDController::drawLayer3D(CloudsHUDLayerSet layer, ofCamera* cam, ofVec2f& offset){ ofPushMatrix(); // Hook up to the camera to keep the layer steady. ofMatrix4x4 baseRotation; ofTranslate(cam->getPosition()); baseRotation.makeRotationMatrix(cam->getOrientationQuat()); ofMultMatrix(baseRotation); ofVec3f camPos = ofVec3f(); //cam->getPosition(); // Calculate the base position. static ofVec3f yAxis = ofVec3f(0.0, 1.0, 0.0); static ofVec3f xAxis = ofVec3f(1.0, 0.0, 0.0); // ofVec3f basePos = camPos + (cam->getLookAtDir().getScaled(layerDistance[layer])); // ofVec3f basePos(0, 0, -layerDistance[layer]); ofVec3f basePos(offset.x, offset.y, -layerDistance[layer]); basePos.rotate(layerRotationH[layer], camPos, yAxis); basePos.rotate(layerRotationV[layer], camPos, xAxis); // Get the total layer bounds. ofRectangle layerBounds; for(int i = 0; i < layerSets[layer].size(); i++){ if (i == 0) layerBounds = layerSets[layer][i]->svg.getBounds(); else layerBounds.growToInclude(layerSets[layer][i]->svg.getBounds()); } // Translate to the layer center pos. ofVec3f layerPos = basePos + (getCenter(false) - layerBounds.getCenter()); ofTranslate(layerPos); if (layerBillboard[layer] == CLOUDS_HUD_BILLBOARD_OCULUS) { // Billboard rotation using the Oculus orientation. float angle; ofVec3f axis; CloudsVisualSystem::getOculusRift().getOrientationQuat().getRotate(angle, axis); ofRotate(angle, axis.x, axis.y, axis.z); ofScale(-1, 1, 1); } else if (layerBillboard[layer] == CLOUDS_HUD_BILLBOARD_CAMERA) { // Billboard rotation using the camera. ofNode node; node.setPosition(layerPos); node.lookAt(camPos); ofVec3f axis; float angle; node.getOrientationQuat().getRotate(angle, axis); ofRotate(angle, axis.x, axis.y, axis.z); } else { // ofRotateY(layerRotationH[layer]); // ofRotateX(layerRotationV[layer]); ofScale(-1, 1, 1); } // Debug circle. // ofSetColor(255); // ofCircle(0, 0, 25); // Transform for rendering the layer. ofScale(-scaleAmt, -scaleAmt, 1); ofTranslate(-layerBounds.getCenter()); // Draw the video player if we're on the right layer. if (layer == CLOUDS_HUD_PROJECT_EXAMPLE && videoPlayer.isPlaying()) { ofSetColor(255, 255, 255, 255*0.7); if( !bSkipAVideoFrame ){ // videoPlayer.draw( videoBounds.x, videoBounds.y, videoBounds.width, videoBounds.height ); } } // Draw the layer. ofSetColor(255); drawLayer(layer); // Draw the home button if we're on the right layer. if (layer == CLOUDS_HUD_LOWER_THIRD && bDrawHome && hudOpenMap[CLOUDS_HUD_LOWER_THIRD]) { home.draw(); } // Draw the associated text labels. for( map<string, CloudsHUDLabel*>::iterator it=hudLabelMap.begin(); it!= hudLabelMap.end(); ++it ){ bool bFound = false; for(int i = 0; i < layerSets[layer].size(); i++){ if (layerSets[layer][i]->svg.getMeshByID(it->first) != NULL) { bFound = true; break; } } if (bFound) { (it->second)->draw(); } } ofPopMatrix(); }
void TentaculatBoss::onDestroy() { EntityManager::getInstance().createGreenParticles(getCenter(), 150); // Low-pitched explosion SoundSystem::playSound("boom.ogg", 0.3f); }
void Wisp::attack(Selector target, centimicrosecond now) { lastAttack = now; target.selected()->addIncoming(new WispAttack(getCenter(), t(), attackDamage)); }
bool BF3PointCircle::getRobustCircle(const cvb::CvContourChainCode& contour, const unsigned int maxVotes, const unsigned int maxAccu, const int maxInvalidVotesInSeries, BFCircle& circle) { cvb::CvChainCodes::const_iterator it = contour.chainCode.begin(); cvb::CvChainCodes::const_iterator it_beg = contour.chainCode.begin(); cvb::CvChainCodes::const_iterator it_end = contour.chainCode.end(); unsigned int x = contour.startingPoint.x; unsigned int y = contour.startingPoint.y; BFContour bfContour; while(it != it_end) { bfContour.add(BFCoordinate<int>(static_cast<int>(x),static_cast<int>(y))); x += cvb::cvChainCodeMoves[*it][0]; y += cvb::cvChainCodeMoves[*it][1]; it++; } const unsigned int nContourPoints = bfContour.getPixelCount(); BFRectangle rect = bfContour.getBounds(); int nRows = bfRound(rect.getHeight()); int nCols = bfRound(rect.getWidth()); int x0 = bfRound(rect.getX0()); int y0 = bfRound(rect.getY0()); BFCoordinate<int> topLeft(x0,y0); // generate 2d histogram for circle center estimation Eigen::MatrixXi H = Eigen::MatrixXi::Zero(nRows, nCols); unsigned int votes = 0; int invalidVotesInSeries = 0; while(votes < maxVotes) { unsigned int randIndex1 = (rand() % nContourPoints); unsigned int randIndex2 = (rand() % nContourPoints); while(randIndex2 == randIndex1) randIndex2 = (rand() % nContourPoints); unsigned int randIndex3 = (rand() % nContourPoints); while(randIndex3 == randIndex2 || randIndex3 == randIndex1) randIndex3 = (rand() % nContourPoints); BFCoordinate<int> c1 = bfContour.getCoordinate(randIndex1) - topLeft; BFCoordinate<int> c2 = bfContour.getCoordinate(randIndex2) - topLeft; BFCoordinate<int> c3 = bfContour.getCoordinate(randIndex3) - topLeft; BFCoordinate<double> center; bool validCenter = getCenter(c1,c2,c3,center); if(!validCenter) { votes--; invalidVotesInSeries++; if(invalidVotesInSeries > maxInvalidVotesInSeries) { return false; } continue; } invalidVotesInSeries = 0; double cxD = center.getX(); double cyD = center.getY(); int cx = bfRound(cxD); int cy = bfRound(cyD); if(cx < 0 || cy < 0 || cx >= nRows || cy >= nCols) { continue; } else { H(cx,cy) += 1; if(H(cx,cy) >= static_cast<int>(maxAccu)) { break; } } votes++; } int finalX = 0; int finalY = 0; H.maxCoeff(&finalX,&finalY); finalX += bfRound(x0); finalY += bfRound(y0); // generate 1d histogram for circle radius estimation Eigen::VectorXi K = Eigen::VectorXi::Zero(bfMax(nRows,nCols)); it = it_beg; x = contour.startingPoint.x; y = contour.startingPoint.y; while(it != it_end) { int r = bfRound(sqrt(pow(static_cast<double>(static_cast<int>(x)-finalX),2.0) + pow(static_cast<double>(static_cast<int>(y)-finalY),2.0))); if(r < K.rows()) { K(r) += 1; } x += cvb::cvChainCodeMoves[*it][0]; y += cvb::cvChainCodeMoves[*it][1]; it++; } int finalR = 0; K.maxCoeff(&finalR); circle.set(finalX,finalY,finalR); return true; }
void CylinderMesh::construct() { int i, firstTop ; int steps = (unsigned int)(complexity * 64.0f) ; float angle ; Point normal ; Box bounds = getBounds() ; Point center = getCenter() ; float radius = getRadius() ; Primitive p ; p.type = Primitive::NoMaterial | Primitive::Strip | Primitive::Indexed ; if (steps < 4) steps = 4 ; if (steps > 64) steps = 64 ; steps &= ~1 ; // Bottom addVertex (center.x(), center.y(), bounds.min.z()) ; for (angle = 0.0f, i = 0 ; i < steps ; i++, angle += 2.0f*M_PI/(float)steps) { addVertex (cosf(angle)*radius + center.x(), sinf(angle)*radius + center.y(), bounds.min.z()) ; } for (i = 1 ; i <= steps ; i++) { p.firstElement = indices.size() ; p.numElements = 3 ; indices.push_back (0) ; indices.push_back (i) ; indices.push_back (i == steps ? 1 : i+1) ; primitives.push_back(p) ; } // Top firstTop = verts.size() ; addVertex (center.x(), center.y(), bounds.max.z()) ; for (angle = 0.0f, i = 0 ; i < steps ; i++, angle += 2.0f*M_PI/(float)steps) { addVertex (cosf(angle)*radius + center.x(), sinf(angle)*radius + center.y(), bounds.max.z()) ; } for (i = 1 ; i <= steps ; i++) { p.firstElement = indices.size() ; p.numElements = 3 ; indices.push_back (firstTop) ; indices.push_back (firstTop+(i == steps ? 1 : i+1)) ; indices.push_back (firstTop+i) ; primitives.push_back(p) ; } // Walls int pos ; for (pos = indices.size(), i = 0 ; i < steps-1 ; i++, pos += 4) { indices.push_back (i+1) ; indices.push_back (firstTop+i+1) ; indices.push_back (i+2) ; indices.push_back (firstTop+i+2) ; p.firstElement = pos ; p.numElements = 4 ; primitives.push_back(p) ; } indices.push_back (i+1) ; indices.push_back (firstTop+i+1) ; indices.push_back (1) ; indices.push_back (firstTop+1) ; p.firstElement = pos ; p.numElements = 4 ; primitives.push_back(p) ; // Other stuff setFrames (1) ; setParent (-1) ; calculateBounds() ; calculateCenter() ; calculateRadius() ; }
SphereF Box3F::getBoundingSphere() const { return SphereF( getCenter(), getGreatestDiagonalLength() / 2.f ); }
XnBoundingBox3D RectPrism::getBoundingBox() { return calcBoundingBox(getCenter(), getBoundingBoxSize()); }
Box2d MgBaseRect::getRect() const { return Box2d(getCenter(), getWidth(), getHeight()); }
float RectPrism::getCenterDistSq(XnPoint3D p) { return dist_sq(p, getCenter()); }
/** * Overrides drawing of subentities. This is only ever called for solid fills. */ void RS_Hatch::draw(RS_Painter* painter, RS_GraphicView* view, double& /*patternOffset*/) { if (!data.solid) { for (RS_Entity* se=firstEntity(); se!=NULL; se = nextEntity()) { view->drawEntity(painter,se); } return; } QPainterPath path; QList<QPolygon> paClosed; QPolygon pa; // QPolygon jp; // jump points // loops: if (needOptimization==true) { for (RS_Entity* l=firstEntity(RS2::ResolveNone); l!=NULL; l=nextEntity(RS2::ResolveNone)) { if (l->rtti()==RS2::EntityContainer) { RS_EntityContainer* loop = (RS_EntityContainer*)l; loop->optimizeContours(); } } needOptimization = false; } // loops: for (RS_Entity* l=firstEntity(RS2::ResolveNone); l!=NULL; l=nextEntity(RS2::ResolveNone)) { l->setLayer(getLayer()); if (l->rtti()==RS2::EntityContainer) { RS_EntityContainer* loop = (RS_EntityContainer*)l; // edges: for (RS_Entity* e=loop->firstEntity(RS2::ResolveNone); e!=NULL; e=loop->nextEntity(RS2::ResolveNone)) { e->setLayer(getLayer()); switch (e->rtti()) { case RS2::EntityLine: { QPoint pt1(RS_Math::round(view->toGuiX(e->getStartpoint().x)), RS_Math::round(view->toGuiY(e->getStartpoint().y))); QPoint pt2(RS_Math::round(view->toGuiX(e->getEndpoint().x)), RS_Math::round(view->toGuiY(e->getEndpoint().y))); // if (! (pa.size()>0 && (pa.last() - pt1).manhattanLength()<=2)) { // jp<<pt1; // } pa<<pt1<<pt2; } break; case RS2::EntityArc: { // QPoint pt1(RS_Math::round(view->toGuiX(e->getStartpoint().x)), // RS_Math::round(view->toGuiY(e->getStartpoint().y))); // if (! (pa.size()>0 && (pa.last() - pt1).manhattanLength()<=2)) { // jp<<pt1; // } QPolygon pa2; RS_Arc* arc=static_cast<RS_Arc*>(e); painter->createArc(pa2, view->toGui(arc->getCenter()), view->toGuiDX(arc->getRadius()), arc->getAngle1(), arc->getAngle2(), arc->isReversed()); pa<<pa2; } break; case RS2::EntityCircle: { RS_Circle* circle = static_cast<RS_Circle*>(e); // QPoint pt1(RS_Math::round(view->toGuiX(circle->getCenter().x+circle->getRadius())), // RS_Math::round(view->toGuiY(circle->getCenter().y))); // if (! (pa.size()>0 && (pa.last() - pt1).manhattanLength()<=2)) { // jp<<pt1; // } RS_Vector c=view->toGui(circle->getCenter()); double r=view->toGuiDX(circle->getRadius()); #if QT_VERSION >= 0x040400 path.addEllipse(QPoint(c.x,c.y),r,r); #else path.addEllipse(c.x - r, c.y + r, 2.*r, 2.*r); // QPolygon pa2; // painter->createArc(pa2, view->toGui(circle->getCenter()), // view->toGuiDX(circle->getRadius()), // 0.0, // 2*M_PI, // false); // pa<<pa2; #endif } break; case RS2::EntityEllipse: if(static_cast<RS_Ellipse*>(e)->isArc()) { QPolygon pa2; auto ellipse=static_cast<RS_Ellipse*>(e); painter->createEllipse(pa2, view->toGui(ellipse->getCenter()), view->toGuiDX(ellipse->getMajorRadius()), view->toGuiDX(ellipse->getMinorRadius()), ellipse->getAngle(), ellipse->getAngle1(), ellipse->getAngle2(), ellipse->isReversed() ); pa<<pa2; }else{ QPolygon pa2; auto ellipse=static_cast<RS_Ellipse*>(e); painter->createEllipse(pa2, view->toGui(ellipse->getCenter()), view->toGuiDX(ellipse->getMajorRadius()), view->toGuiDX(ellipse->getMinorRadius()), ellipse->getAngle(), ellipse->getAngle1(), ellipse->getAngle2(), ellipse->isReversed() ); path.addPolygon(pa2); } break; default: break; } if( pa.size()>2 && pa.first() == pa.last()) { paClosed<<pa; pa.clear(); } } } } if(pa.size()>2){ pa<<pa.first(); paClosed<<pa; } for(int i=0;i<paClosed.size();i++){ path.addPolygon(paClosed.at(i)); } painter->setBrush(painter->getPen().getColor()); painter->disablePen(); painter->drawPath(path); // pa<<jp; // painter->setBrush(painter->getPen().getColor()); // painter->disablePen(); // painter->drawPolygon(pa); }
QList<RVector> RArc::getCenterPoints() const { QList<RVector> ret; ret.append(getCenter()); return ret; }
BSphere AABB::getBSphere() const { Point3 center = getCenter(); return BSphere(center, (center - max).length()); }
Vec3f CylinderDistribution3D::generate(void) const { Vec3f Result; switch(getSurfaceOrVolume()) { case SURFACE: { std::vector<Real32> Areas; //Min Cap Areas.push_back(0.5*osgAbs(getMaxTheta() - getMinTheta())*(getOuterRadius()*getOuterRadius() - getInnerRadius()*getInnerRadius())); //Max Cap Areas.push_back(Areas.back() + 0.5*osgAbs(getMaxTheta() - getMinTheta())*(getOuterRadius()*getOuterRadius() - getInnerRadius()*getInnerRadius())); //Inner Tube Areas.push_back(Areas.back() + getInnerRadius()*osgAbs(getMaxTheta() - getMinTheta()) * getHeight()); //Outer Tube Areas.push_back(Areas.back() + getOuterRadius()*osgAbs(getMaxTheta() - getMinTheta()) * getHeight()); bool HasTubeSides(osgAbs(getMaxTheta() - getMinTheta()) - 6.283185 < -0.000001); if(HasTubeSides) { //MinTheta Tube Side Areas.push_back(Areas.back() + (getOuterRadius() - getInnerRadius()) * getHeight()); //MaxTheta Tube Side Areas.push_back(Areas.back() + (getOuterRadius() - getInnerRadius()) * getHeight()); } Real32 PickEdge(RandomPoolManager::getRandomReal32(0.0,1.0)); if(PickEdge < Areas[0]/Areas.back()) { //Max Cap Real32 Temp(osgSqrt(RandomPoolManager::getRandomReal32(0.0,1.0))); Real32 Radius(getInnerRadius() + Temp*(getOuterRadius() - getInnerRadius())); Real32 Theta( RandomPoolManager::getRandomReal32(getMinTheta(),getMaxTheta()) ); Result = getCenter().subZero() + (Radius*osgSin(Theta))*getTangent() + (Radius*osgCos(Theta))*getBinormal() + (getHeight()/static_cast<Real32>(2.0))*getNormal(); } else if(PickEdge < Areas[1]/Areas.back()) { //Min Cap Real32 Temp(osgSqrt(RandomPoolManager::getRandomReal32(0.0,1.0))); Real32 Radius(getInnerRadius() + Temp*(getOuterRadius() - getInnerRadius())); Real32 Theta( RandomPoolManager::getRandomReal32(getMinTheta(),getMaxTheta()) ); Result = getCenter().subZero() + (Radius*osgSin(Theta))*getTangent() + (Radius*osgCos(Theta))*getBinormal() + (-getHeight()/static_cast<Real32>(2.0))*getNormal(); } else if(PickEdge < Areas[2]/Areas.back()) { //Inner Tube Real32 Theta( RandomPoolManager::getRandomReal32(getMinTheta(),getMaxTheta()) ); Real32 Height(RandomPoolManager::getRandomReal32(-getHeight()/2.0,getHeight()/2.0)); Result = getCenter().subZero() + getInnerRadius()*osgSin(Theta)*getTangent() + getInnerRadius()*osgCos(Theta)*getBinormal() + Height*getNormal(); } else if(PickEdge < Areas[3]/Areas.back()) { //Outer Tube Real32 Theta( RandomPoolManager::getRandomReal32(getMinTheta(),getMaxTheta()) ); Real32 Height(RandomPoolManager::getRandomReal32(-getHeight()/2.0,getHeight()/2.0)); Result = getCenter().subZero() + getOuterRadius()*osgSin(Theta)*getTangent() + getOuterRadius()*osgCos(Theta)*getBinormal() + Height*getNormal(); } else if(HasTubeSides && PickEdge < Areas[4]/Areas.back()) { //MinTheta Tube Side Real32 Temp(osgSqrt(RandomPoolManager::getRandomReal32(0.0,1.0))); Real32 Radius(getInnerRadius() + Temp*(getOuterRadius() - getInnerRadius())); Real32 Height(RandomPoolManager::getRandomReal32(-getHeight()/2.0,getHeight()/2.0)); Result = getCenter().subZero() + (Radius*osgSin(getMinTheta()))*getTangent() + (Radius*osgCos(getMinTheta()))*getBinormal() + Height*getNormal(); } else if(HasTubeSides && PickEdge < Areas[5]/Areas.back()) { //MaxTheta Tube Side Real32 Temp(osgSqrt(RandomPoolManager::getRandomReal32(0.0,1.0))); Real32 Radius(getInnerRadius() + Temp*(getOuterRadius() - getInnerRadius())); Real32 Height(RandomPoolManager::getRandomReal32(-getHeight()/2.0,getHeight()/2.0)); Result = getCenter().subZero() + (Radius*osgSin(getMaxTheta()))*getTangent() + (Radius*osgCos(getMaxTheta()))*getBinormal() + Height*getNormal(); } else { assert(false && "Should never reach this point"); } break; } case VOLUME: default: { //To get a uniform distribution across the disc get a uniformly distributed allong 0.0 - 1.0 //Then Take the square root of that. This gives a square root distribution from 0.0 - 1.0 //This square root distribution is used for the random radius because the area of a disc is //dependant on the square of the radius, i.e it is a quadratic function Real32 Temp(osgSqrt(RandomPoolManager::getRandomReal32(0.0,1.0))); Real32 Radius(getInnerRadius() + Temp*(getOuterRadius() - getInnerRadius())); Real32 Height(RandomPoolManager::getRandomReal32(-getHeight()/2.0,getHeight()/2.0)); Real32 Theta( RandomPoolManager::getRandomReal32(getMinTheta(),getMaxTheta()) ); Result = getCenter().subZero() + (Radius*osgSin(Theta))*getTangent() + (Radius*osgCos(Theta))*getBinormal() + Height*getNormal(); break; } } return Result; }
int center(int pos) { getSize(pos,0); return getCenter(pos,0, sz[pos]); }
void Player::onActionDown(Action::ID action) { switch (action) { case Action::UP: m_animator.setAnimation(*this, m_animation_up); break; case Action::DOWN: m_animator.setAnimation(*this, m_animation_down); break; case Action::USE_COOLER: if (m_icecubes > 0) { // Play sound effect and launch particles SoundSystem::playSound("cooler.ogg"); m_snowflakes_emitter.setPosition(getCenter()); m_snowflakes_emitter.createParticles(40); // Reset heat m_panel.setIcecubes(--m_icecubes); m_heat = 0.f; m_overheat = false; m_panel.setOverheat(false); } else { SoundSystem::playSound("disabled.ogg"); } break; case Action::USE_MISSILE: if (m_missiles > 0 && m_missile_launcher.isReady()) { m_panel.setMissiles(--m_missiles); m_missile_launcher.shoot<Missile>(0); } else { SoundSystem::playSound("disabled.ogg"); } break; case Action::USE_LASER: if (m_overheat) { SoundSystem::playSound("disabled.ogg"); } break; default: break; } // Detect Konami code sequence if (action == m_konami_code[m_current_konami_index]) { ++m_current_konami_index; if (m_current_konami_index == KONAMI_CODE_LENGTH) { applyKonamiCode(); m_current_konami_index = 0; // Reset } } else { m_current_konami_index = 0; } }