void ProgressBarWidget::render() { double progress = 0.0; if (currentStep >= 0 && currentStep < totalSteps) progress = (double) currentStep / (double) totalSteps; else progress = 1.0; WidgetPoint corner = getBoundingRect().getCorner(); WidgetPoint dimensions = getBoundingRect().getDimensions(); double right = corner.getX() + progress * dimensions.getX(); double done_right = corner.getX() + dimensions.getX(); double bottom = corner.getY()+dimensions.getY(); OpenGL::Color::glColor(OpenGL::Color::GREY); glBegin(GL_QUADS); WidgetRenderer::glVertex(corner); WidgetRenderer::glVertex(WidgetPoint(done_right, corner.getY())); WidgetRenderer::glVertex(WidgetPoint(done_right, bottom)); WidgetRenderer::glVertex(WidgetPoint(corner.getX(), bottom)); glEnd(); OpenGL::Color::glColor(OpenGL::Color::WHITE); glBegin(GL_QUADS); WidgetRenderer::glVertex(corner); WidgetRenderer::glVertex(WidgetPoint(right, corner.getY())); WidgetRenderer::glVertex(WidgetPoint(right, bottom)); WidgetRenderer::glVertex(WidgetPoint(corner.getX(), bottom)); glEnd(); }
void TextWidget::render() { double ratioNow = SDL::Projector::getInstance()->getAspectRatio(); if(lastRenderedRatio != ratioNow) { lastRenderedRatio = ratioNow; dirty = true; } if(dirty) { preRender(); } if(data.empty() || !stringTexture.hasTexture()) { return; // empty text, or error in pre-rendering } WidgetPoint corner = getBoundingRect().getCorner(); WidgetPoint dimensions = getBoundingRect().getDimensions(); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, stringTexture.getTextureID()); glColor3f(1.0f, 1.0f, 1.0f); // comment this out to disable font transparency glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBegin(GL_QUADS); double width = dimensions.getX() * widthFactor; double height = dimensions.getY() * heightFactor; // scale dimensions to take the larger power-of-2 texture into account // this way it looks the same no matter how big the texture actually is WidgetPoint topLeft = corner; WidgetPoint lowerLeft = corner; WidgetPoint topRight = corner; WidgetPoint lowerRight = corner; lowerLeft.addY(height); lowerRight.addY(height); topRight.addX(width); lowerRight.addX(width); glTexCoord2i(0, 0); WidgetRenderer::glVertex(topLeft); glTexCoord2i(1, 0); WidgetRenderer::glVertex(topRight); glTexCoord2i(1, 1); WidgetRenderer::glVertex(lowerRight); glTexCoord2i(0, 1); WidgetRenderer::glVertex(lowerLeft); glEnd(); glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); }
void PSV_ChartItem::createUpAxisi(const PSV_AxisItemParam &axisParam) { QMap<int, QVariant> param; QRectF m_rect = getBoundingRect(); QRectF boundingRect = QRectF(m_chartRect.x(),m_rect.top() ,m_chartRect.width(),m_margin_total_up); param.insert(PSV::boundingRect,boundingRect); QFont markFont; markFont.setPointSizeF(PSV_Public::getMinLenght(m_rect) * axisParam.m_fontRatio * 0.03); param.insert(PSV::markFont,markFont); param.insert(PSV::hasArrow,axisParam.m_hasArrow); param.insert(PSV::maxValue,m_max_x); param.insert(PSV::minValue,m_min_x); if(axisParam.m_list.count() > 0) { m_upAxisItem = new PSV_AxisUpItem(param,axisParam.m_list,this); param.insert(PSV::isCenter,axisParam.m_isCenter); } else { m_upAxisItem = new PSV_AxisUpItem(param,this); } m_upAxisItem->getRange(m_max_x,m_min_x,m_rangeX); }
Polygon PolygonInterface::boundingRect(void) const { double minX, minY, maxX, maxY; getBoundingRect(&minX, &minY, &maxX, &maxY); return Rectangle(Point(minX, minY), Point(maxX, maxY)); }
void toprsGadlReader::getMaxSize( int resLevel,int& maxX, int& maxY ) const { int aGdalBandIndex = 0; maxX = 0; maxY = 0; //if(theOverview.valid() && theOverview->isValidRLevel(resLevel))// xizhi { //toprsIRect rect = theOverview->getBoundingRect(resLevel);//xizhi toprsIRect rect = getBoundingRect(resLevel); if(!rect.hasNAN()) { maxX = rect.width(); maxY = rect.height(); } return; } for(aGdalBandIndex=1; (int)aGdalBandIndex <= (int)GDALGetRasterCount(theDataset); ++aGdalBandIndex) { GDALRasterBandH aBand = resolveRasterBand(resLevel, aGdalBandIndex); if(aBand) { maxY = toprs::max<int>((int)GDALGetRasterBandYSize(aBand), maxY); maxX = toprs::max<int>((int)GDALGetRasterBandXSize(aBand), maxX); } else { break; } } }
void GameOverPanel::render(Scene& parent) { SDL_Window * win = parent.app().getWindow(); int width, height; SDL_GetWindowSize(win, &width, &height); Rect rect = getBoundingRect(win); glPushAttrib(GL_ENABLE_BIT); { glMatrixMode(GL_PROJECTION); glDisable(GL_LIGHTING); glPushMatrix(); { glLoadIdentity(); glOrtho(0, width, 0, height, -1, 1); glMatrixMode(GL_MODELVIEW); glPushMatrix(); { glLoadIdentity(); glBindTexture(texture); float alpha = 0; float translateY = 0; if(animTime > coolDownTime) { float diff = (animTime - coolDownTime) / (animTotalTime - coolDownTime); if(diff > 1) diff = 1; alpha = diff; translateY = translationYLength * (1 - diff) * (1 - diff); } glTranslate(Vector3::down * translateY); glColor(Vector3::one, alpha); glBegin(GL_QUADS); { glTexCoord2f(0, 0); glVertex2f(rect.left(), height - rect.top()); glTexCoord2f(0, 1); glVertex2f(rect.left(), height - rect.bottom()); glTexCoord2f(1, 1); glVertex2f(rect.right(), height - rect.bottom()); glTexCoord2f(1, 0); glVertex2f(rect.right(), height - rect.top()); } glEnd(); } glPopMatrix(); } glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); } glPopAttrib(); if(animTime < animTotalTime) { animTime += parent.app().getFrameTime(); } }
void PageItem_NoteFrame::layout() { if (!invalid || l_notes.isEmpty()) return; if (!m_Doc->flag_layoutNotesFrames) return; if (itemText.length() == 0) return; if ((masterFrame() != NULL) && masterFrame()->invalid) return; //while layouting notes frames undo should be disabled UndoManager::instance()->setUndoEnabled(false); if (m_nstyle->isAutoNotesWidth() && (m_width != m_masterFrame->width())) { oldWidth = m_width = m_masterFrame->width(); updateClip(); } if ((m_Doc->appMode == modeEdit) && isSelected()) updateNotesText(); PageItem_TextFrame::layout(); int oldH = m_height; if (notesStyle()->isAutoNotesHeight()) { if (frameOverflows()) { //increase height while text don`t fit in frame double maxH = m_Doc->currentPage()->height() - m_xPos; while (frameOverflows()) { oldHeight = m_height += 8; updateClip(false); invalid = true; PageItem_TextFrame::layout(); if (m_height >= maxH) break; } } double hackValue = 0.5; oldHeight = m_height = ceil(maxY) + m_textDistanceMargins.bottom() + hackValue; updateConstants(); updateClip(); invalid = true; PageItem_TextFrame::layout(); } if (oldH != height()) { if (masterFrame() != NULL) { foreach(PageItem_NoteFrame* nF, masterFrame()->notesFramesList()) nF->invalid = true; } } invalid = false; m_Doc->regionsChanged()->update(getBoundingRect()); UndoManager::instance()->setUndoEnabled(true); }
//***************************************************************************** // METHOD: ossimImageSource::getValidImageVertices() //***************************************************************************** void ossimImageSource::getValidImageVertices(std::vector<ossimIpt>& validVertices, ossimVertexOrdering ordering, ossim_uint32 resLevel)const { ossimImageSource* inter = PTR_CAST(ossimImageSource, getInput(0)); if(inter) { return inter->getValidImageVertices(validVertices, ordering, resLevel); } ossimIrect boundingRect = getBoundingRect(resLevel); validVertices.clear(); if(ordering == OSSIM_CLOCKWISE_ORDER) { validVertices.push_back(boundingRect.ul()); validVertices.push_back(boundingRect.ur()); validVertices.push_back(boundingRect.lr()); validVertices.push_back(boundingRect.ll()); } else { validVertices.push_back(boundingRect.ul()); validVertices.push_back(boundingRect.ll()); validVertices.push_back(boundingRect.lr()); validVertices.push_back(boundingRect.ur()); } }
void rspfPixelFlipper::initialize() { OpenThreads::ScopedLock<OpenThreads::Mutex> scopeLock(theMutex); rspfImageSourceFilter::initialize(); theValidVertices.clear(); theBoundingRects.clear(); rspf_uint32 rlevels = getNumberOfDecimationLevels(); rspf_uint32 idx = 0; if(rlevels) { if(theValidVertices.size() != rlevels) { theValidVertices.resize(rlevels); } if(theBoundingRects.size() != rlevels) { theBoundingRects.resize(rlevels); } for(idx = 0; idx < rlevels; ++idx) { std::vector<rspfIpt> validVertices; getValidImageVertices(validVertices, RSPF_CLOCKWISE_ORDER, idx); theValidVertices[idx] = rspfPolygon(validVertices); theBoundingRects[idx] = getBoundingRect(idx); } } }
//***************************************************************************** // METHOD: rspfImageSource::getValidImageVertices() //***************************************************************************** void rspfImageSource::getValidImageVertices(std::vector<rspfIpt>& validVertices, rspfVertexOrdering ordering, rspf_uint32 resLevel)const { rspfImageSource* inter = PTR_CAST(rspfImageSource, getInput(0)); if(inter) { return inter->getValidImageVertices(validVertices, ordering, resLevel); } rspfIrect boundingRect = getBoundingRect(resLevel); validVertices.clear(); if(ordering == RSPF_CLOCKWISE_ORDER) { validVertices.push_back(boundingRect.ul()); validVertices.push_back(boundingRect.ur()); validVertices.push_back(boundingRect.lr()); validVertices.push_back(boundingRect.ll()); } else { validVertices.push_back(boundingRect.ul()); validVertices.push_back(boundingRect.ll()); validVertices.push_back(boundingRect.lr()); validVertices.push_back(boundingRect.ur()); } }
void PSV_ChartItem::createRightAxisi(const PSV_AxisItemParam &axisParam) { QMap<int, QVariant> param; QRectF m_rect = getBoundingRect(); QRectF boundingRect = QRectF(m_chartRect.right(), m_chartRect.top() ,m_margin_total_right, m_chartRect.height()); param.insert(PSV::boundingRect,boundingRect); QFont markFont; markFont.setPointSizeF(PSV_Public::getMinLenght(m_rect) * axisParam.m_fontRatio * 0.03); param.insert(PSV::markFont,markFont); param.insert(PSV::hasArrow,axisParam.m_hasArrow); param.insert(PSV::maxValue,m_max_y_right); param.insert(PSV::minValue,m_min_y_right); if(axisParam.m_list.count() > 0) { m_rightAxisItem = new PSV_AxisRightItem(param,axisParam.m_list,this); param.insert(PSV::isCenter,axisParam.m_isCenter); } else { m_rightAxisItem = new PSV_AxisRightItem(param,this); } QVariant max; QVariant min; m_rightAxisItem->getRange(max,min); m_max_y_right = max.toDouble(); m_min_y_right = min.toDouble(); }
void PSV_ChartItem::updateChartRect() { QRectF m_rect = getBoundingRect(); m_chartRect = QRectF(m_rect.x() + m_margin_total_left ,m_rect.y()+m_margin_total_up ,m_rect.width() - m_margin_total_left - m_margin_total_right ,m_rect.height() - m_margin_total_up - m_margin_total_down); }
void HoverPoints::_movePoint( const int index, const QPointF& point, const bool emitUpdate ) { // Get the point bounding object to move it. _tfPoints[index] = getBoundPoint( point, getBoundingRect(), _locks.at( index )); if( emitUpdate ) firePointChange(); }
void EllipseAnnotation::drawEllipseAnnotaion(QPainter *painter) { QPainterPath path; // first we invert the painter since we have our coordinate system inverted. // inversion is required to draw the elliptic curves at correct angles. painter->scale(1.0, -1.0); painter->translate(0, ((-boundingRect().top()) - boundingRect().bottom())); applyLinePattern(painter); applyFillPattern(painter); qreal startAngle = StringHandler::getNormalizedAngle(mStartAngle); qreal endAngle = StringHandler::getNormalizedAngle(mEndAngle); if ((startAngle - endAngle) == 0) { path.addEllipse(getBoundingRect()); painter->drawPath(path); } else { painter->drawPie(getBoundingRect(), mStartAngle*16, mEndAngle*16 - mStartAngle*16); } }
QPainterPath RectangleAnnotation::shape() const { QPainterPath path; path.addRoundedRect(getBoundingRect(), mRadius, mRadius); if (mFillPattern == StringHandler::FillNone) return addPathStroker(path); else return path; }
void BitmapAnnotation::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { Q_UNUSED(option); Q_UNUSED(widget); if(!mImageSource.isEmpty()) { //open file from image source QByteArray data = QByteArray::fromBase64(mImageSource.toLatin1()); QImage image; if(image.loadFromData(data)) painter->drawImage(getBoundingRect(), image.mirrored()); } else { QImage image(mFileName); painter->drawImage(getBoundingRect(), image.mirrored()); } }
QPainterPath EllipseAnnotation::shape() const { QPainterPath path; qreal startAngle = StringHandler::getNormalizedAngle(mStartAngle); qreal endAngle = StringHandler::getNormalizedAngle(mEndAngle); if ((startAngle - endAngle) == 0) { path.addEllipse(getBoundingRect()); if (mFillPattern == StringHandler::FillNone) { return addPathStroker(path); } else { return path; } } path.addEllipse(getBoundingRect()); return path; }
void Hint::render(Scene& parent) { SDL_Window * win = parent.app().getWindow(); int width, height; SDL_GetWindowSize(win, &width, &height); Rect rect = getBoundingRect(win); glPushAttrib(GL_ENABLE_BIT); { glMatrixMode(GL_PROJECTION); glDisable(GL_LIGHTING); glPushMatrix(); { glLoadIdentity(); glOrtho(0, width, 0, height, -1, 1); glMatrixMode(GL_MODELVIEW); glPushMatrix(); { glLoadIdentity(); glBindTexture(texture); glColor(Vector3::one, 1-animTime); glBegin(GL_QUADS); { glTexCoord2f(0, 0); glVertex2f(rect.left(), height - rect.top()); glTexCoord2f(0, 1); glVertex2f(rect.left(), height - rect.bottom()); glTexCoord2f(1, 1); glVertex2f(rect.right(), height - rect.bottom()); glTexCoord2f(1, 0); glVertex2f(rect.right(), height - rect.top()); } glEnd(); } glPopMatrix(); } glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); } glPopAttrib(); if(fadingOut) { animTime += parent.app().getFrameTime(); if(animTime > 1){ animTime = 0; fadingOut = false; disable(); } } }
Projectile::Projectile(Type type, const TextureHolder& textures) : Entity(1) , mType(type) , mSprite(textures.get(Table[type].texture), Table[type].textureRect) , mTargetDirection() { centerOrigin(mSprite); // Add particle system for missiles if (isGuided()) { std::unique_ptr<EmitterNode> smoke(new EmitterNode(Particle::Smoke)); smoke->setPosition(0.f, getBoundingRect().height / 2.f); attachChild(std::move(smoke)); std::unique_ptr<EmitterNode> propellant(new EmitterNode(Particle::Propellant)); propellant->setPosition(0.f, getBoundingRect().height / 2.f); attachChild(std::move(propellant)); } }
void SceneNode::drawBoundingRect(sf::RenderTarget& target, sf::RenderStates) const { sf::FloatRect rect = getBoundingRect(); sf::RectangleShape shape; shape.setPosition(sf::Vector2f(rect.left, rect.top)); shape.setSize(sf::Vector2f(rect.width, rect.height)); shape.setFillColor(sf::Color::Transparent); shape.setOutlineColor(sf::Color::Green); shape.setOutlineThickness(1.f); target.draw(shape); }
DiasporaClusterGraphicsItem::DiasporaClusterGraphicsItem(float fx, float fy, ClusterItem &item) : _corner(QPointF(fx,fy)), _x(fx), _y(fy), _clusterItem(item), _referenceSize(DiasporaDefaultFonts::TitleFont().pointSizeF()) { _size = QSizeF(200,200); _itemName = _clusterItem.name(); _rect = getBoundingRect(); _currentScene = 0; this->setFlag(QGraphicsItem::ItemIsSelectable,true); //this->setFlag(QGraphicsItem::ItemIsMovable,true); }
bool SkillsNode::mouseIntersects(sf::RenderWindow& window) { sf::FloatRect aux; aux = getBoundingRect(); if(sf::Mouse::getPosition(window).x >= aux.left && sf::Mouse::getPosition(window).x <= aux.left + aux.width && sf::Mouse::getPosition(window).y >= aux.top && sf::Mouse::getPosition(window).y <= aux.top + aux.height) { return true; } else { return false; } }
void PSV_ChartItem::adjustTitlePos() { if(m_titleItem == NULL) { return; } // qreal margin = getData(PSV::margin).toDouble(); // PSV_Public::printMes(margin,"margin"); qreal x = m_chartRect.left() + 0.5 * (m_chartRect.width() - m_titleItem->boundingRect().width()); qreal dy = 0; if(m_upAxisItem != NULL) { dy += m_upAxisItem->validRect().height(); } qreal y = getBoundingRect().top() + (m_margin_total_up - m_margin_up - getData(PSV::margin,3).toInt() - m_titleItem->boundingRect().height()) * 0.5; m_titleItem->setPos(x,y); }
void PSV_ChartItem::createHVLine() { QLineF hLine(m_chartRect.left(),m_chartRect.center().y(),m_chartRect.right(),m_chartRect.center().y()); QLineF vLine(m_chartRect.center().x(),m_chartRect.top(),m_chartRect.center().x(),m_chartRect.bottom()); m_hLineItem = new QGraphicsLineItem(hLine,this); m_vLineItem = new QGraphicsLineItem(vLine,this); m_boundingItem = new QGraphicsRectItem(getBoundingRect(),this); m_hLineItem->hide(); m_vLineItem->hide(); m_boundingItem->hide(); m_hLineItem->setZValue(10001); m_vLineItem->setZValue(10001); m_boundingItem->setZValue(10001); m_currentMesItem = new QGraphicsTextItem(this); // m_currentMesItem->setFont(m_valueFont); }
double PSV_ChartItem::getAxisY(float dataY, int adjust) const { double y = m_margin_total_up + getBoundingRect().top(); QRectF rect = m_chartRect; if(!rect.isValid()) { return y; } if(*m_max_y_curP > *m_min_y_curP) { y = rect.bottom() - 1.0 * (dataY - *m_min_y_curP) / (*m_max_y_curP - *m_min_y_curP) * rect.height() - adjust; } else { PSV_Public::printMes(QString("*m_max_y_curP(%1) <= *m_min_y_curP(%2)") .arg(*m_max_y_curP).arg(*m_min_y_curP)); } return y; }
void HoverPoints::setPoints( const QPolygonF& listPoints ) { // If the given list of points is not equal to the current list, // clear all the points. if( listPoints.size() != _tfPoints.size()) _fingerPointMapping.clear(); _tfPoints.clear(); // Update the current _tfPoints_ list to the given list of points. for( int32_t i = 0; i < listPoints.size(); ++i ) _tfPoints << getBoundPoint( listPoints.at(i), getBoundingRect(), 0 ); // Update the new list of points before drawinf them. _locks.clear(); if( _tfPoints.size() > 0 ) { _locks.resize( _tfPoints.size()); _locks.fill(0); } }
rspfAppFixedTileCache::rspfAppFixedCacheId rspfCacheTileSource::getCacheId(rspf_uint32 resLevel) { rspfAppFixedTileCache::rspfAppFixedCacheId result = -1; if(theRLevelCacheList.empty()) { initializeRlevelCache(); } if(resLevel < theRLevelCacheList.size()) { if(theRLevelCacheList[resLevel] <0) { rspfIpt cacheTileSize(theFixedTileSize); if(theUseInputTileSizeFlag) { cacheTileSize = rspfIpt(rspf::min(static_cast<rspf_int32>(theInputConnection->getTileWidth()), static_cast<rspf_int32>(1024)), rspf::min(static_cast<rspf_int32>(theInputConnection->getTileHeight()), static_cast<rspf_int32>(1024))); } //std::cout << cacheTileSize << std::endl; rspfIrect rect = getBoundingRect(resLevel); if((cacheTileSize.x > static_cast<rspf_int64>(rect.width()))&& (cacheTileSize.y > static_cast<rspf_int64>(rect.height()))) { cacheTileSize.x = rspf::max(static_cast<rspf_int64>(rect.width()), static_cast<rspf_int64>(64)); cacheTileSize.y = rspf::max(static_cast<rspf_int64>(rect.height()), static_cast<rspf_int64>(64)); } rect.stretchToTileBoundary(theFixedTileSize); theRLevelCacheList[resLevel] = rspfAppFixedTileCache::instance()->newTileCache(rect, cacheTileSize); } result = theRLevelCacheList[resLevel]; } return result; }
//--------------------------------------------------------------------- // ● 地形との当たり判定を行う //--------------------------------------------------------------------- u32 GameObject::judgeCollisionToMap( float* dx_, float* dy_ ) { *dx_ = *dy_ = 0.0f; // 当たり判定全般は、判定用の矩形がある場合にのみ行う const LRect* rc = getBoundingRect(); if ( rc ) { LRect col_rect = *rc; // 移動した後の座標 LVector3 d_pos = mPosition + mVelocity; // 移動前の判定用矩形の座標 float px = col_rect.x; float py = col_rect.y; // 矩形を移動させて、移動後の判定領域にする col_rect.x += static_cast< int >( mVelocity.x ); col_rect.y += static_cast< int >( mVelocity.y ); // 移動量 (いまはつかわないかも) LVector3 dest = mPosition - d_pos; // マップとの当たり判定結果の、修正後の座標を格納する変数 LVector3 result_pos; u32 result = MapManager::getInstance()->collision( col_rect, dest, &result_pos ); // 移動前と比べて、移動量を求める *dx_ = result_pos.x - px; *dy_ = result_pos.y - py; return result; } return 0; }
void Creature::updateCurrent(sf::Time dt, CommandQueue &commands) { updateAnimation(dt); if(isDestroyed() && !hasBeenSacrificed()) { if(mEmitter) { mEmitter->update(dt, commands); mDestroyedSince += dt; } else { // blood std::unique_ptr<EmitterNode> e(new EmitterNode(Particle::Default)); e->setPosition(sf::Vector2f(0.f, -32.f)); mEmitter = e.get(); attachChild(std::move(e)); // text if(randomInt(4) == 0) { Command command; command.category = Category::UILayer; command.action = derivedAction<SceneNode>([this] (SceneNode& node, sf::Time) { std::string str = StringTable[randomInt(StringTable.size())]; std::unique_ptr<CombatTextNode> tn(new CombatTextNode(str, mFonts)); tn->setPosition(sf::Vector2f(getPosition().x, getPosition().y-getBoundingRect().height/2)); node.attachChild(std::move(tn)); }); commands.push(command); } } } mAIController.update(commands, *this); Entity::updateCurrent(dt, commands); }
QPainterPath BitmapAnnotation::shape() const { QPainterPath path; path.addRoundedRect(getBoundingRect(), mCornerRadius, mCornerRadius); return path; }