// AnimatedPath(Point const & start_point, Point const & end_point, int const & beginn, int const & duration, // Fill const & fill = Fill(), Stroke const & stroke = Stroke()) // : Shape(fill, stroke), start_point(start_point), end_point(end_point), beginn(beginn), duration(duration) { } // AnimatedPath(Stroke const & stroke = Stroke()) : Shape(Color::Transparent, stroke) { } // Polygon & operator<<(Point const & point) // { // points.push_back(point); // return *this; // } std::string toString(Layout const & layout) const { std::stringstream ss; ss << elemStart("path"); ss << "d=\""; std::stringstream startPoint; std::stringstream beforePoint; std::stringstream afterPoint; startPoint << "M " << translateX(start_point.x, layout) << "," << translateY(start_point.y, layout) << " "; ss << startPoint.str(); beforePoint << "L " << translateX(start_point.x, layout) << "," << translateY(start_point.y, layout) << "\""; afterPoint << "L " << translateX(end_point.x, layout) << "," << translateY(end_point.y, layout) << "\""; ss << beforePoint.str() << " "<< fill.toString(layout) << stroke.toString(layout)<< ">"; ss << elemStart("animate"); ss << " attributeType=\"XML\" attributeName=\"d\" fill=\"freeze\" "; ss << "from=\"" << startPoint.str() << " " << beforePoint.str() << " "; ss << "to=\"" << startPoint.str() << " " << afterPoint.str() << ""; ss << " begin=\"" << beginn << "\" "; ss << "dur=\"" << duration << "\""; ss << emptyElemEnd(); ss << elemEnd("path"); // for (unsigned i = 0; i < points.size(); ++i) // ss << translateX(points[i].x, layout) << "," << translateY(points[i].y, layout) << " "; // ss << fill.toString(layout) << stroke.toString(layout) << emptyElemEnd(); return ss.str(); }
std::string toString(Layout const & layout) const { std::stringstream ss; ss << elemStart("line") << attribute("x1", translateX(start_point.x, layout)) << attribute("y1", translateY(start_point.y, layout)) << attribute("x2", translateX(end_point.x, layout)) << attribute("y2", translateY(end_point.y, layout)) << stroke.toString(layout) << emptyElemEnd(); return ss.str(); }
void SceneGraphDeviceContext::DrawComplexBezierPath(vrv::Point bezier1[4], vrv::Point bezier2[4]) { // Note: No support for vertex antialiasing. Use a top-level QQuickView with multisample antialiasing. // TODO: Add vertex antialiasing, refer to // 1) Qt sources for "void QSGBasicInternalRectangleNode::updateGeometry()" in // qtdeclarative/src/quick/scenegraph/qsgbasicinternalrectanglenode.cpp // 2) https://stackoverflow.com/questions/28125425/smooth-painting-in-custom-qml-element vrv::Pen currentPen = m_penStack.top(); int segmentCount = 16; QSGGeometryNode *node = new QSGGeometryNode; QSGGeometry *geometry = new QSGGeometry(QSGGeometry::defaultAttributes_Point2D(), 2 * segmentCount); geometry->setDrawingMode(QSGGeometry::DrawTriangleStrip); node->setGeometry(geometry); node->setFlag(QSGNode::OwnsGeometry); QSGFlatColorMaterial *material = new QSGFlatColorMaterial; material->setColor(static_cast<QRgb>(currentPen.GetColour())); node->setMaterial(material); node->setFlag(QSGNode::OwnsMaterial); auto calculateCubicBezierPoint = [](vrv::Point p[4], float t) -> std::tuple<float, float> { auto invt = 1 - t; auto x = invt * invt * invt * p[0].x + 3 * invt * invt * t * p[1].x + 3 * invt * t * t * p[2].x + t * t * t * p[3].x; auto y = invt * invt * invt * p[0].y + 3 * invt * invt * t * p[1].y + 3 * invt * t * t * p[2].y + t * t * t * p[3].y; return std::make_tuple(x, y); }; // This loop calculates the bezier points for the inner and the outer line and add them as vertices. The list of // vertices is built so that points from the inner and outer line are alternating. This allows to draw a filled area // with DrawTriangleStrip. QSGGeometry::Point2D *vertices = geometry->vertexDataAsPoint2D(); for (int i = 0; i < segmentCount; ++i) { float bezierPointX = 0; float bezierPointY = 0; float currentSegment = i / static_cast<float>(segmentCount - 1); // Calculate bezier point on bezier1 std::tie(bezierPointX, bezierPointY) = calculateCubicBezierPoint(bezier1, currentSegment); vertices[i * 2].set(translateX(bezierPointX), translateY(bezierPointY)); // Calculate bezier point on bezier2 std::tie(bezierPointX, bezierPointY) = calculateCubicBezierPoint(bezier2, currentSegment); vertices[i * 2 + 1].set(translateX(bezierPointX), translateY(bezierPointY)); } node->markDirty(QSGNode::DirtyGeometry); AddGeometryNode(node); }
//---------------------------------------------------------- void ofRectangle::alignToHorz(const float& targetX, ofAlignHorz thisHorzAnchor) { if(thisHorzAnchor != OF_ALIGN_HORZ_IGNORE) { translateX(targetX - getHorzAnchor(thisHorzAnchor)); } else { ofLogVerbose("ofRectangle") << "alignToHorz(): thisHorzAnchor == OF_ALIGN_HORZ_IGNORE, no alignment applied"; } }
std::string toString(Layout const & layout) const { std::stringstream ss; ss << elemStart("text") << attribute("x", translateX(origin.x, layout)) << attribute("y", translateY(origin.y, layout)) << fill.toString(layout) << stroke.toString(layout) << font.toString(layout) << ">" << content << elemEnd("text"); return ss.str(); }
std::string toString(Layout const & layout) const { std::stringstream ss; ss << elemStart("circle") << attribute("cx", translateX(center.x, layout)) << attribute("cy", translateY(center.y, layout)) << attribute("r", translateScale(radius, layout)) << fill.toString(layout) << stroke.toString(layout) << emptyElemEnd(); return ss.str(); }
void SceneGraphDeviceContext::DrawPolygon(int n, vrv::Point points[], int xoffset, int yoffset, int) { // Note: No support for vertex antialiasing. Use a top-level QQuickView with multisample antialiasing. // TODO: Add vertex antialiasing, refer to // 1) Qt sources for "void QSGBasicInternalRectangleNode::updateGeometry()" in // qtdeclarative/src/quick/scenegraph/qsgbasicinternalrectanglenode.cpp // 2) https://stackoverflow.com/questions/28125425/smooth-painting-in-custom-qml-element // TODO: This function only works for convex polygons. At the moment verovio calls this function only with n = 4. // Maybe this function should be renamed to DrawConvexPolygon vrv::Pen currentPen = m_penStack.top(); QSGGeometry *geometry; geometry = new QSGGeometry(QSGGeometry::defaultAttributes_Point2D(), n); geometry->setDrawingMode(QSGGeometry::DrawTriangleStrip); QSGFlatColorMaterial *material = new QSGFlatColorMaterial; material->setColor(static_cast<QRgb>(currentPen.GetColour())); // Reorder points so that they can be drawn with DrawTriangleStrip. int counter1 = 0; int counter2 = n - 1; for (int i = 0; i < n; i++) { if (i % 2 == 0) { geometry->vertexDataAsPoint2D()[i].set( translateX(points[counter1].x + xoffset), translateY(points[counter1].y + yoffset)); counter1++; } else { geometry->vertexDataAsPoint2D()[i].set( translateX(points[counter2].x + xoffset), translateY(points[counter2].y + yoffset)); counter2--; } } QSGGeometryNode *node = new QSGGeometryNode; node->setGeometry(geometry); node->setFlag(QSGNode::OwnsGeometry); node->setMaterial(material); node->setFlag(QSGNode::OwnsMaterial); AddGeometryNode(node); }
int translateXTest() { START_TEST_CASE; int x2; int x1 = 1; x2 = translateX(x1); SHOULD_BE(x2 == 5); x1 = -1; x2 = translateX(x1); SHOULD_BE(x2 == -3); x1 = 0; x2 = translateX(x1); SHOULD_BE(x2 == 1); END_TEST_CASE; }
std::string toString(Layout const & layout) const { std::stringstream ss; ss << elemStart("rect") << attribute("x", translateX(edge.x, layout)) << attribute("y", translateY(edge.y, layout)) << attribute("width", translateScale(width, layout)) << attribute("height", translateScale(height, layout)) << fill.toString(layout) << stroke.toString(layout) << emptyElemEnd(); return ss.str(); }
void Transform::applyAnimationValueTranslationX(float tx) { if ((_animationPropertyBitFlag & ANIMATION_TRANSLATION_X_BIT) != ANIMATION_TRANSLATION_X_BIT) { _animationPropertyBitFlag |= ANIMATION_TRANSLATION_X_BIT; setTranslationX(tx); } else { translateX(tx); } }
void SceneGraphDeviceContext::DrawLine(int x1, int y1, int x2, int y2) { vrv::Pen currentPen = m_penStack.top(); QSGGeometry *geometry = new QSGGeometry(QSGGeometry::defaultAttributes_Point2D(), 2); geometry->setDrawingMode(GL_LINES); geometry->setLineWidth(translate(currentPen.GetWidth())); geometry->vertexDataAsPoint2D()[0].set(translateX(x1), translateY(y1)); geometry->vertexDataAsPoint2D()[1].set(translateX(x2), translateY(y2)); QSGFlatColorMaterial *material = new QSGFlatColorMaterial; material->setColor(static_cast<QRgb>(currentPen.GetColour())); QSGGeometryNode *node = new QSGGeometryNode; node->setGeometry(geometry); node->setFlag(QSGNode::OwnsGeometry); node->setMaterial(material); node->setFlag(QSGNode::OwnsMaterial); AddGeometryNode(node); }
void SceneGraphDeviceContext::SetTextPositionAndAlignment(int x, int y, vrv::data_HORIZONTALALIGNMENT alignment) { m_currentTextQuickItem->setX(static_cast<double>(translateX(x))); m_currentTextQuickItem->setY(static_cast<double>(translateY(y))); switch (alignment) { case vrv::HORIZONTALALIGNMENT_left: m_currentTextQuickItem->setAlignment(Qt::AlignLeft); break; case vrv::HORIZONTALALIGNMENT_right: m_currentTextQuickItem->setAlignment(Qt::AlignRight); break; case vrv::HORIZONTALALIGNMENT_center: m_currentTextQuickItem->setAlignment(Qt::AlignHCenter); break; case vrv::HORIZONTALALIGNMENT_justify: m_currentTextQuickItem->setAlignment(Qt::AlignJustify); break; default: break; } }
std::string toString(Layout const & layout) const { std::stringstream ss; ss << elemStart("polyline"); ss << "points=\""; for (unsigned i = 0; i < points.size(); ++i) ss << translateX(points[i].x, layout) << "," << translateY(points[i].y, layout) << " "; ss << "\" "; ss << fill.toString(layout) << stroke.toString(layout) << emptyElemEnd(); return ss.str(); }
void SceneGraphDeviceContext::DrawRectangle(int x, int y, int width, int height) { vrv::Pen currentPen = m_penStack.top(); QSGSimpleRectNode *node = new QSGSimpleRectNode; node->setColor(static_cast<QRgb>(currentPen.GetColour())); qreal rectX = static_cast<qreal>(translateX(x)); qreal rectY = static_cast<qreal>(translateY(y)); qreal rectWidth = static_cast<qreal>(translate(width)); qreal rectHeight = static_cast<qreal>(translate(height)); node->setRect(rectX, rectY, rectWidth, rectHeight); AddGeometryNode(node); }
void SceneGraphDeviceContext::DrawCircle(int x, int y, int radius) { // Note: No support for vertex antialiasing. Use a top-level QQuickView with multisample antialiasing. // TODO: Add vertex antialiasing, refer to // 1) Qt sources for "void QSGBasicInternalRectangleNode::updateGeometry()" in // qtdeclarative/src/quick/scenegraph/qsgbasicinternalrectanglenode.cpp // 2) https://stackoverflow.com/questions/28125425/smooth-painting-in-custom-qml-element vrv::Pen currentPen = m_penStack.top(); int segmentCount = 16; QSGGeometryNode *node = new QSGGeometryNode(); QSGGeometry *geometry = new QSGGeometry(QSGGeometry::defaultAttributes_Point2D(), segmentCount); geometry->setDrawingMode(QSGGeometry::DrawTriangleFan); node->setGeometry(geometry); node->setFlag(QSGNode::OwnsGeometry); QSGFlatColorMaterial *material = new QSGFlatColorMaterial; material->setColor(static_cast<QRgb>(currentPen.GetColour())); node->setMaterial(material); node->setFlag(QSGNode::OwnsMaterial); // This draws individual triangles from the first point (center) to every outer point by using DrawTriangleFan. QSGGeometry::Point2D *vertices = geometry->vertexDataAsPoint2D(); int numPoints = geometry->vertexCount(); vertices[0].x = translateX(x); vertices[0].y = translateY(y); for (int i = 1; i < numPoints; ++i) { double theta = i * 2 * M_PI / (numPoints - 2); vertices[i].x = translateX(x + radius * static_cast<float>(std::cos(theta))); vertices[i].y = translateY(y - radius * static_cast<float>(std::sin(theta))); } node->markDirty(QSGNode::DirtyGeometry); AddGeometryNode(node); }
void callMotionFunc(int x, int y) { switch(g_mouseCurrentButton) { case LEFT : rotateHead ((g_mousePreviousX - x) / 10.0); nodHead ((g_mousePreviousY - y) / 10.0); break; case MIDDLE : rotateZ ((g_mousePreviousX - x) / 10.0); zoom ((g_mousePreviousY - y) / 10.0); break; case RIGHT : translateY ((g_mousePreviousX - x) / 10.0); translateX ((g_mousePreviousY - y) / 10.0); break; default: break; } g_mousePreviousX = x; g_mousePreviousY = y; }
void SceneGraphDeviceContext::DrawMusicText(const std::wstring &text, int x, int y, bool) { Q_ASSERT(m_fontStack.top()); QFont font(QString::fromStdString(m_fontStack.top()->GetFaceName())); // Note: Verovio calls it point size but it is actually pixel size. Qt can only handle pixel size in int, thus it // would be better to use point size. int pixelSize = static_cast<int>(translate(m_fontStack.top()->GetPointSize())); font.setPixelSize(pixelSize); // Memory management is handled by m_quickItem (set in AddQuickItem) auto musicTextQuickItem = new TextQuickItem(); musicTextQuickItem->appendText(QString::fromStdWString(text), font); musicTextQuickItem->setX(static_cast<double>(translateX(x))); musicTextQuickItem->setY(static_cast<double>(translateY(y))); musicTextQuickItem->calcPos(); AddQuickItem(musicTextQuickItem); }
//---------------------------------------------------------- void ofRectangle::translate(float dx, float dy) { translateX(dx); translateY(dy); }
void Point2f::translate(const Vector2f &tv) { translateX(tv.getX()); translateY(tv.getY()); }
//---------------------------------------------------------- void ofRectangle::translate(const ofPoint& dp) { translateX(dp.x); translateY(dp.y); }
void Point2f::translate(float xt, float yt) { translateX(xt); translateY(yt); }