void MeshBase::setVertex(int i, const Math::Vector2 &v) { if (!m_vdata->set(i, v.x(), v.y())) MMWARNING("Failed to assign values (%f, %f) to vertex %d", v.x(), v.y(), i); }
void RendererPlplot::draw_point(const math::Vector2 &v, const Rgb &rgb, enum PointStyle s) { int code; _pls->col0(get_color_id(rgb)); switch (s) { default: case PointStyleDot: code = 1; break; case PointStyleCross: code = 2; break; case PointStyleRound: code = 4; break; case PointStyleSquare: code = 6; break; case PointStyleTriangle: code = 11; break; } PLFLT x = v.x(), y = v.y(); _pls->poin(1, &x, &y, code); }
Containers::Array<char> StbPngImageConverter::doExportToData(const ImageView2D& image) { #ifndef MAGNUM_TARGET_GLES if(image.storage().swapBytes()) { Error() << "Trade::StbPngImageConverter::exportToData(): pixel byte swap is not supported"; return nullptr; } #endif if(image.type() != PixelType::UnsignedByte) { Error() << "Trade::StbPngImageConverter::exportToData(): unsupported pixel type" << image.type(); return nullptr; } Int components; switch(image.format()) { #if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2)) case PixelFormat::Red: #endif #ifdef MAGNUM_TARGET_GLES2 case PixelFormat::Luminance: #endif components = 1; break; #if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2)) case PixelFormat::RG: #endif #ifdef MAGNUM_TARGET_GLES2 case PixelFormat::LuminanceAlpha: #endif components = 2; break; case PixelFormat::RGB: components = 3; break; case PixelFormat::RGBA: components = 4; break; default: Error() << "Trade::StbPngImageConverter::exportToData(): unsupported pixel format" << image.format(); return nullptr; } /* Data properties */ std::size_t offset; Math::Vector2<std::size_t> dataSize; std::tie(offset, dataSize, std::ignore) = image.dataProperties(); /* Reverse rows in image data */ Containers::Array<unsigned char> reversedData{image.data().size()}; for(Int y = 0; y != image.size().y(); ++y) { std::copy(image.data<unsigned char>() + offset + y*dataSize.x(), image.data<unsigned char>() + offset + (y + 1)*dataSize.x(), reversedData + (image.size().y() - y - 1)*dataSize.x()); } Int size; unsigned char* const data = stbi_write_png_to_mem(reversedData, dataSize.x(), image.size().x(), image.size().y(), components, &size); CORRADE_INTERNAL_ASSERT(data); /* Wrap the data in an array with custom deleter (we can't use delete[]) */ Containers::Array<char> fileData{reinterpret_cast<char*>(data), std::size_t(size), [](char* data, std::size_t) { std::free(data); }}; return fileData; }
void RendererPlplot::draw_circle(const math::Vector2 &c, double r, const Rgb &rgb, bool filled) { _pls->col0(get_color_id(rgb)); std::cout << "draw_circle was not tested (added 8th parameter to compile" << std::endl; exit(-1); _pls->arc(c.x(), c.y(), r, r, 0., 360., 360., filled); }
Math::VectorPair2 TRegularPolygon::get_edge(const Math::Vector2 &point) const { // find sector start angle double a = Math::lp_floor(atan2(point.y(), point.x()) - _angle, (double)_edge_cnt / (2.0 * M_PI)); // find sector edge coordinates return Math::VectorPair2(_radius * cos(_angle + a), _radius * sin(_angle + a), _radius * cos(_angle + a + _a_step), _radius * sin(_angle + a + _a_step)); }
void TCurveBase::normal(Math::Vector3 &normal, const Math::Vector3 &point) const { Math::Vector2 d; derivative(point.project_xy(), d); normal = Math::Vector3(d.x(), d.y(), -1.0); normal.normalize(); }
void Block::Draw(sf::RenderTarget& renderTarget) { MATH::Vector2 position = GetPosition(); if(_highlight) { _blockSprite.SetColor(_color + sf::Color(255, 255, 255, 255 * sinf(_highlightPhase))); position -= MATH::Vector2(0.0f, 5.0f * sinf(_highlightPhase)); } _blockSprite.SetPosition(position.sfVec()); renderTarget.Draw(_blockSprite); }
void RendererPlplot::draw_text(const math::Vector2 &c, const math::Vector2 &dir, const std::string &str, TextAlignMask a, int size, const Rgb &rgb) { double j = .5; if (a & TextAlignLeft) j = 0.; else if (a & TextAlignRight) j = 1.; _pls->schr(size/3., 1.); _pls->col0(get_color_id(rgb)); _pls->ptex(c.x(), c.y(), dir.x(), dir.y(), j, str.c_str()); }
bool BounceColliderComponent::collision(ColliderComponent &c, float d, const CollisionData &data) { MMUNUSED(c); MMUNUSED(d); MMUNUSED(data); const Math::Vector2 &l_vel = movement()->velocity(); const float l_mag = l_vel.magnitude(); const Math::Vector2 l_normal = l_vel.normalized(l_mag); Math::Vector2 l_pvel = (l_normal * (2.f * l_normal.dot(l_vel * -1.f)) + l_vel); movement()->velocity() = l_pvel.normalize(l_pvel.magnitude()) * l_mag; return(true); }
void EnemyAIBase::SetEnemyEyeSight( math::Vector2 eye ) { if( m_enemyMine ){ eye.Normalize(); m_enemyMine->m_eye = eye; } }
bool TRegularPolygon::inside(const Math::Vector2 &point) const { double d = Math::square(point.x()) + Math::square(point.y()); // check against circumscribed circle if (d > Math::square(_radius)) return false; // check against inscribed circle if (d < Math::square(_i_radius)) return true; Math::VectorPair2 e(get_edge(point)); return ((point.y() - e.y0()) * (e.x1() - e.x0()) - (point.x() - e.x0()) * (e.y1() - e.y0()) > 0); }
template<UnsignedInt dimensions, class T> typename DimensionTraits<dimensions, T>::MatrixType aspectRatioFix(AspectRatioPolicy aspectRatioPolicy, const Math::Vector2<T>& projectionScale, const Vector2i& viewport) { /* Don't divide by zero / don't preserve anything */ if(projectionScale.x() == 0 || projectionScale.y() == 0 || viewport.x() == 0 || viewport.y() == 0 || aspectRatioPolicy == AspectRatioPolicy::NotPreserved) return {}; Math::Vector2<T> relativeAspectRatio = Math::Vector2<T>(viewport)*projectionScale; /* Extend on larger side = scale larger side down Clip on smaller side = scale smaller side up */ return Camera<dimensions, T>::aspectRatioScale( (relativeAspectRatio.x() > relativeAspectRatio.y()) == (aspectRatioPolicy == AspectRatioPolicy::Extend) ? Vector2(relativeAspectRatio.y()/relativeAspectRatio.x(), T(1.0)) : Vector2(T(1.0), relativeAspectRatio.x()/relativeAspectRatio.y())); }
template<UnsignedInt dimensions, class T> MatrixTypeFor<dimensions, T> aspectRatioFix(AspectRatioPolicy aspectRatioPolicy, const Math::Vector2<T>& projectionScale, const Vector2i& viewport) { /* Don't divide by zero / don't preserve anything */ if(projectionScale.x() == 0 || projectionScale.y() == 0 || viewport.x() == 0 || viewport.y() == 0 || aspectRatioPolicy == AspectRatioPolicy::NotPreserved) return {}; CORRADE_INTERNAL_ASSERT((projectionScale > Math::Vector2<T>(0)).all() && (viewport > Vector2i(0)).all()); Math::Vector2<T> relativeAspectRatio = Math::Vector2<T>(viewport)*projectionScale; /* Extend on larger side = scale larger side down Clip on smaller side = scale smaller side up */ return MatrixTypeFor<dimensions, T>::scaling(Math::Vector<dimensions, T>::pad( (relativeAspectRatio.x() > relativeAspectRatio.y()) == (aspectRatioPolicy == AspectRatioPolicy::Extend) ? Math::Vector2<T>(relativeAspectRatio.y()/relativeAspectRatio.x(), T(1)) : Math::Vector2<T>(T(1), relativeAspectRatio.x()/relativeAspectRatio.y()), T(1))); }
bool GLVideo::DrawLine(const math::Vector2 &p1, const math::Vector2 &p2, const Color& color1, const Color& color2) { if (GetLineWidth() <= 0.0f) return true; if (p1 == p2) return true; static const math::Vector2 offsetFix(0.5f, 0.5f); const math::Vector2 a(p1 + offsetFix), b(p2 + offsetFix); const math::Vector2 v2Dir = a - b; const float length = v2Dir.Length() + 0.5f; const float angle = math::RadianToDegree(math::GetAngle(v2Dir)); DrawRectangle(a, math::Vector2(GetLineWidth(), length), color2, color2, color1, color1, angle, Sprite::EO_CENTER_BOTTOM); return true; }
void TCurveBase::derivative(const Math::Vector2 & xy, Math::Vector2 & dxdy) const { double abserr; struct curve_gsl_params_s params; gsl_function gsl_func; gsl_func.params = ¶ms; params.c = this; params.x = xy.x(); params.y = xy.y(); gsl_func.function = gsl_func_sagitta_x; gsl_deriv_central(&gsl_func, xy.x(), 1e-6, &dxdy.x(), &abserr); gsl_func.function = gsl_func_sagitta_y; gsl_deriv_central(&gsl_func, xy.y(), 1e-6, &dxdy.y(), &abserr); }
bool Polygon::inside(const math::Vector2 &p) const { unsigned int s = _vertices.size(); if (s < 3) return false; unsigned int count = 0; const math::Vector2 *w = &_vertices[s - 1]; // FIXME optimize for (unsigned int i = 0; i < s; i++) { const math::Vector2 *v = &_vertices[i]; // Algorithm from http://local.wasp.uwa.edu.au/~pbourke/geometry/insidepoly/ if ((((v->y() <= p.y()) && (p.y() < w->y())) || ((w->y() <= p.y()) && (p.y() < v->y()))) && (p.x() < (w->x() - v->x()) * (p.y() - v->y()) / (w->y() - v->y()) + v->x())) count++; w = v; } return (count & 1) != 0; }
constexpr static Math::Matrix4<T> aspectRatioScale(const Math::Vector2<T>& scale) { return Math::Matrix4<T>::scaling({scale.x(), scale.y(), 1.0f}); }
void TLens::draw_2d_edge(TRenderer &r, const TSurface &left, double l_y, const TSurface &right, double r_y, LensEdge type, const TElement *ref) const { const Math::Vector3 l3(0., l_y, left.get_curve()->sagitta(Math::Vector2(0., l_y))); const Math::Vector2 l2(left.get_transform_to(ref).transform(l3).project_zy()); const Math::Vector3 r3(0., r_y, right.get_curve()->sagitta(Math::Vector2(0., r_y))); const Math::Vector2 r2(right.get_transform_to(ref).transform(r3).project_zy()); switch (type) { case StraightEdge: { if (fabs(l2.y() - r2.y()) > 1e-6) { double m; if (fabs(l2.y()) > fabs(r2.y())) { m = l2.y(); r.draw_segment(Math::VectorPair2(r2.x(), m, r2.x(), r2.y()), left.get_color(r)); } else { m = r2.y(); r.draw_segment(Math::VectorPair2(l2.x(), m, l2.x(), l2.y()), left.get_color(r)); } r.draw_segment(Math::VectorPair2(l2.x(), m, r2.x(), m), left.get_color(r)); break; } } case SlopeEdge: r.draw_segment(l2, r2, left.get_color(r)); break; } }
/** * @param v A vector * @param size Maximum size of the returning vector * * @return If the size if v is greater than size, returns * a resized version of v with the specified size. Otherwise * just return a copy of v. */ inline Vector2 truncate(const math::Vector2& v, float size) { return (v.sizeSqr() > size * size) ? resize(v, size) : v; }
bool TRingBase::inside(const Math::Vector2 &point) const { double d = Math::square(point.x()) + Math::square(point.y()); return d <= Math::square(_radius) && d >= Math::square(_hole_radius); }
bool SDLInput::SetCursorPositionF(math::Vector2 v2Pos) { return SetCursorPosition(v2Pos.ToVector2i()); }
double EllipseBase::get_outter_radius(const math::Vector2 &dir) const { return _xr > _yr ? sqrt(math::square(_yr) / (1. - _e2 * math::square(dir.x()))) : sqrt(math::square(_xr) / (1. - _e2 * math::square(dir.y()))); }
bool EllipseBase::inside(const math::Vector2 &point) const { return (math::square(point.x()) + math::square(point.y() * _xy_ratio) <= math::square(_xr)); }