Пример #1
0
void FlyingModeManipulator::dragMiddle(
        const Vector2i& to,
        const Vector2i& from )
{
    Viewport& viewport = _window.getViewPort();
    const float x = ( to.x() - from.x( )) * _window.getMotionSpeed();
    const float y = ( to.y() - from.y( )) * _window.getMotionSpeed();
    viewport.translate( Vector3f( x, y , 0.f ), true );
}
Пример #2
0
void FlyingModeManipulator::dragLeft(
        const Vector2i& to,
        const Vector2i& from )
{
    const float du = ( to.x() - from.x( )) * _window.getRotateSpeed();
    const float dv = ( to.y() - from.y( )) * _window.getRotateSpeed();
    Viewport& viewport = _window.getViewPort();
    viewport.rotate( viewport.getPosition(), du, dv, true );
}
Пример #3
0
void FlyingModeManipulator::dragRight(
        const Vector2i& to,
        const Vector2i& from )
{
    const float fwd = -( to.y() - from.y( )) * _window.getMotionSpeed();
    Viewport& viewport = _window.getViewPort();
    const Vector3f dir( 0.f, 0.f , 1.f );
    viewport.translate( dir*fwd, false );
}
Пример #4
0
bool Font::FontTexture::findEmpty(const Vector2i& size, Vector2i& cursor_out)
{
	if(size.x() >= textureSize.x() || size.y() >= textureSize.y())
		return false;

	if(writePos.x() + size.x() >= textureSize.x() &&
		writePos.y() + rowHeight + size.y() + 1 < textureSize.y())
	{
		// row full, but it should fit on the next row
		// move cursor to next row
		writePos = Vector2i(0, writePos.y() + rowHeight + 1); // leave 1px of space between glyphs
		rowHeight = 0;
	}

	if(writePos.x() + size.x() >= textureSize.x() ||
		writePos.y() + size.y() >= textureSize.y())
	{
		// nope, still won't fit
		return false;
	}

	cursor_out = writePos;
	writePos[0] += size.x() + 1; // leave 1px of space between glyphs

	if(size.y() > rowHeight)
		rowHeight = size.y();

	return true;
}
Пример #5
0
void KisColorSelectorRing::paintCache()
{
    QImage cache(m_cachedSize, m_cachedSize, QImage::Format_ARGB32_Premultiplied);
    
    Vector2i center(cache.width()/2., cache.height()/2.);
    
    for(int x=0; x<cache.width(); x++) {
        for(int y=0; y<cache.height(); y++) {
            Vector2i currentPoint((float)x, (float)y);
            Vector2i relativeVector = currentPoint-center;

            qreal currentRadius = relativeVector.squaredNorm();
            currentRadius=sqrt(currentRadius);
            
            if(currentRadius < outerRadius()+1
               && currentRadius > innerRadius()-1)
            {

                float angle = std::atan2((float)relativeVector.y(), (float)relativeVector.x())+((float)M_PI);
                angle/=2*((float)M_PI);
                angle*=359.f;
                if(currentRadius < outerRadius()
                   && currentRadius > innerRadius()) {
                    cache.setPixel(x, y, m_cachedColors.at(angle));
                }
                else {
                    // draw antialiased border
                    qreal coef=1.;
                    if(currentRadius > outerRadius()) {
                        // outer border
                        coef-=currentRadius;
                        coef+=outerRadius();
                    }
                    else {
                        // inner border
                        coef+=currentRadius;
                        coef-=innerRadius();
                    }
                    coef=qBound(qreal(0.), coef, qreal(1.));
                    int red=qRed(m_cachedColors.at(angle));
                    int green=qGreen(m_cachedColors.at(angle));
                    int blue=qBlue(m_cachedColors.at(angle));

                    // the format is premultiplied, so we have to take care of that
                    QRgb color = qRgba(red*coef, green*coef, blue*coef, 255*coef);
                    cache.setPixel(x, y, color);
                }
            }
            else {
                cache.setPixel(x, y, qRgba(0,0,0,0));
            }
        }
    }
    m_pixelCache = cache;
}
Пример #6
0
Vector2i Window::preferredSize(NVGcontext *ctx) const {
    Vector2i result = Widget::preferredSize(ctx);

    nvgFontSize(ctx, 18.0f);
    nvgFontFace(ctx, "sans-bold");
    float bounds[4];
    nvgTextBounds(ctx, 0, 0, mTitle.c_str(), nullptr, bounds);

    return result.cwiseMax(Vector2i(
        bounds[2]-bounds[0] + 20, bounds[3]-bounds[1]
    ));
}
Пример #7
0
void AbstractTexture::storageImplementationDefault(GLenum target, GLsizei levels, AbstractTexture::InternalFormat internalFormat, const Vector2i& size) {
    bindInternal();
    /** @todo Re-enable when extension wrangler is available for ES2 */
    #ifndef MAGNUM_TARGET_GLES2
    glTexStorage2D(target, levels, GLenum(internalFormat), size.x(), size.y());
    #else
    //glTexStorage2DEXT(target, levels, GLenum(internalFormat), size.x(), size.y());
    static_cast<void>(target);
    static_cast<void>(levels);
    static_cast<void>(internalFormat);
    static_cast<void>(size);
    #endif
}
Пример #8
0
void GridManager::LinkToMyself(Vector2i p, sep::Axis mirror_axis) {
  Cell* cell = grid_->GetInitCell(p)->m_pCell;

  int coord = mirror_axis == sep::X ? p.x() : p.y();
  if (coord < 2) {
    if (cell->m_pPrev[mirror_axis] != nullptr)
      throw("Next is already not emty");
    cell->m_pPrev[mirror_axis] = cell; // cell->m_vNext[mirror_axis][0]
  } else {
    if (cell->m_pNext[mirror_axis] != nullptr)
      throw("Next is already not emty");
    cell->m_pNext[mirror_axis] = cell; // cell->m_vPrev[mirror_axis][0]
  }
}
Пример #9
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()));
}
Пример #10
0
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)));
}
Пример #11
0
Vector2i CubeMapTexture::getImageSizeImplementationDefault(const Int level) {
    Vector2i size;
    bindInternal();
    glGetTexLevelParameteriv(GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, GL_TEXTURE_WIDTH, &size.x());
    glGetTexLevelParameteriv(GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, GL_TEXTURE_HEIGHT, &size.y());
    return size;
}
Пример #12
0
Vector2i CubeMapTexture::getImageSizeImplementationDSAEXT(const Int level) {
    _created = true;
    Vector2i size;
    glGetTextureLevelParameterivEXT(_id, GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, GL_TEXTURE_WIDTH, &size.x());
    glGetTextureLevelParameterivEXT(_id, GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, GL_TEXTURE_HEIGHT, &size.y());
    return size;
}
Пример #13
0
void Application::toggleFullScreen ()
{
  if (fullscreen)
  {
#ifdef _WIN32
  SetWindowLongPtr(hWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW | WS_VISIBLE);
  SetWindowPos(hWnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE | SWP_FRAMECHANGED | SWP_SHOWWINDOW);
  // ShowWindow(hWnd, SW_SHOWNORMAL);
#endif
  }
  else
  {
#ifdef _WIN32
  SetWindowLongPtr(hWnd, GWL_STYLE, WS_POPUP | WS_VISIBLE);
  SetWindowPos(hWnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE | SWP_FRAMECHANGED | SWP_SHOWWINDOW);
  // ShowWindow(hWnd, SW_SHOWMAXIMIZED);
#endif
  }
  fullscreen = !fullscreen;

  // Set the size.
#ifdef _WIN32
  RECT rect;
  GetClientRect(hWnd, &rect);
  size.set(rect.right, rect.bottom); // left and top are always 0.
#endif

  screenToNDC = Transform::screenToNDC<float>(size);
  if (widget != 0)
  {
    widget->setBounds(Box2i::minSize(Vector2i::zero(), size));
  }
}
Пример #14
0
LRESULT WINAPI wndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
  switch (msg)
  {
  case WM_CREATE:
    ::hWnd = hWnd;
    break;
  case WM_CLOSE:
    onClose();
    break;
  case WM_SIZE:
    {
      int newWidth = LOWORD(lParam);
      int newHeight = HIWORD(lParam);
      size.set(newWidth, newHeight);
      screenToNDC = Transform::screenToNDC<float>(size);
      if (widget != 0)
      {
        widget->setBounds(Box2i::minSize(Vector2i::zero(), size));
      }
    }
    break;
  case WM_SYSKEYDOWN:
  case WM_KEYDOWN:
    if (wParam == VK_RETURN && (lParam & 0xffff) == 1 && GetKeyState(VK_MENU) < 0) // alt-enter
    {
      Application::toggleFullScreen();
    }
    break;
  default:
    return DefWindowProc(hWnd, msg, wParam, lParam);
  }
  return 0;
}
Пример #15
0
void GridManager::GridGeometryToInitialCells() {
  if (!boxes_stack_.size())
    throw("no grid boxes");

  // determine grid size
  Vector2i vMin(boxes_stack_[0]->p), vMax;
  std::for_each(boxes_stack_.begin(), boxes_stack_.end(), [&](GridBox* box) {
    if (box->p.x() < vMin.x())
      vMin.x() = box->p.x();
    if (box->p.y() < vMin.y())
      vMin.y() = box->p.y();

    if (box->p.x() + box->size.x() > vMax.x())
      vMax.x() = box->p.x() + box->size.x();
    if (box->p.y() + box->size.y() > vMax.y())
      vMax.y() = box->p.y() + box->size.y();
  });
  Vector2i size = vMax - vMin + Vector2i(2, 2); // size += 2 for fake cells
  Config::vGridSize = Vector3i(size.x(), size.y(), 1);
  vMin -= Vector2i(1, 1);  // min_p -= 1 for fake cells

  grid_->AllocateInitData();

  std::for_each(boxes_stack_.begin(), boxes_stack_.end(), [&](GridBox* box) {
    for (int x = 0; x < box->size.x(); x++) {
      for (int y = 0; y < box->size.y(); y++) {
        Vector2i tmp_pos = box->p + Vector2i(x, y) - vMin;
        InitCellData* init_cell = grid_->GetInitCell(tmp_pos);
        init_cell->m_eType = sep::NORMAL_CELL;
      }
    }

    for (int x = -1; x < box->size.x() + 1; x++) {
      for (int y = -1; y < box->size.y() + 1; y++) {
        Vector2i tmp_pos = box->p + Vector2i(x, y) - vMin;
        InitCellData* init_cell = grid_->GetInitCell(tmp_pos);
        GasesConfigsMap& init_conds = init_cell->m_mInitConds;
        for (int gas = 0; gas < Config::iGasesNumber; gas++) {
          init_conds[gas] = box->def_config;
        }
        Vector2i size_with_fakes(box->size);
        size_with_fakes += Vector2i(2, 2);
        box->config(x + 1, y + 1, init_conds, size_with_fakes, box->p);
      }
    }
  });
}
Пример #16
0
Eigen::Vector3f unproject(const Eigen::Vector3f &win,
                          const Eigen::Matrix4f &model,
                          const Eigen::Matrix4f &proj,
                          const Vector2i &viewportSize) {
    Eigen::Matrix4f Inverse = (proj * model).inverse();

    Eigen::Vector4f tmp;
    tmp << win, 1;
    tmp(0) = tmp(0) / viewportSize.x();
    tmp(1) = tmp(1) / viewportSize.y();
    tmp = tmp.array() * 2.0f - 1.0f;

    Eigen::Vector4f obj = Inverse * tmp;
    obj /= obj(3);

    return obj.head(3);
}
Пример #17
0
Matrix3f NNUtilities::calcInverseTransformation(const Vector2i& center, const Vector2i& inSize, const Vector2i& outSize, const Angle rotation)
{
  const Vector2i upperLeft = (center.array() - inSize.array() / 2).matrix();
  const Vector2f transformationFactor = (inSize.cast<float>().array() / outSize.cast<float>().array()).matrix();
  //float sin = std::sin(rotation);
  //float cos = std::cos(rotation);

  Matrix3f inverseTransformation; //TODO check rotation
  inverseTransformation(0, 0) = transformationFactor.x();// *cos;
  inverseTransformation(0, 1) = 0;// transformationFactor.x() * (-sin);
  inverseTransformation(1, 0) = 0;// transformationFactor.y() * sin;
  inverseTransformation(1, 1) = transformationFactor.y();// *cos;

  inverseTransformation(0, 2) = upperLeft.x();// +outSize.x() * (1 - cos + sin) / 2 * transformationFactor.x();
  inverseTransformation(1, 2) = upperLeft.y();// +outSize.y() * (1 - sin - cos) / 2 * transformationFactor.y();
  return inverseTransformation;
}
Пример #18
0
void CompoundUpdateOutputVisitor::_generateTiles(TileQueue* queue,
                                                 Compound* compound)
{
    const Vector2i& tileSize = queue->getTileSize();
    const PixelViewport& pvp = compound->getInheritPixelViewport();
    if (!pvp.hasArea())
        return;

    const Vector2i dim(pvp.w / tileSize.x() + ((pvp.w % tileSize.x()) ? 1 : 0),
                       pvp.h / tileSize.y() + ((pvp.h % tileSize.y()) ? 1 : 0));

    std::vector<Vector2i> tiles;
    tiles.reserve(dim.x() * dim.y());

    tiles::generateZigzag(tiles, dim);
    _addTilesToQueue(queue, compound, tiles);
}
Пример #19
0
bool Slider::mouseDragEvent(const Vector2i &p, const Vector2i & /* rel */,
                            int /* button */, int /* modifiers */) {
    if (!mEnabled)
        return false;
    mValue = std::min(std::max((p.x() - mPos.x()) / (float) mSize.x(), (float) 0.0f), (float) 1.0f);
    if (mCallback)
        mCallback(mValue);
    return true;
}
Пример #20
0
Layout LayoutStack::PutSpace(Vector2i size)
{
	auto& b = stack.back();
	Layout l = b.getNext(b.grow);

	if (l.fill == Dir::Down || l.fill == Dir::Up)
	{
		l.across = size.x();
		l.maxFill = size.y();
	}
	else
	{
		l.across = size.y();
		l.maxFill = size.x();
	}
	b.putNext(l);
	return l;
}
Пример #21
0
Eigen::Vector3f project(const Eigen::Vector3f &obj,
                        const Eigen::Matrix4f &model,
                        const Eigen::Matrix4f &proj,
                        const Vector2i &viewportSize) {
    Eigen::Vector4f tmp;
    tmp << obj, 1;

    tmp = model * tmp;

    tmp = proj * tmp;

    tmp = tmp.array() / tmp(3);
    tmp = tmp.array() * 0.5f + 0.5f;
    tmp(0) = tmp(0) * viewportSize.x();
    tmp(1) = tmp(1) * viewportSize.y();

    return tmp.head(3);
}
Пример #22
0
bool Window::mouseButtonEvent(const Vector2i &p, int button, bool down, int modifiers) {
    if (Widget::mouseButtonEvent(p, button, down, modifiers))
        return true;
    if (button == GLFW_MOUSE_BUTTON_1) {
        mDrag = down && (p.y() - mPos.y()) < mTheme->mWindowHeaderHeight;
        return true;
    }
    return false;
}
Пример #23
0
bool ShaderProgram::setUniformValue(const std::string& name, const Vector2i& v)
{
  GLint location = static_cast<GLint>(findUniform(name));
  if (location == -1) {
    m_error = "Could not set uniform " + name + ". No such uniform.";
    return false;
  }
  glUniform2iv(location, 1, v.data());
  return true;
}
void AutomaticCameraCalibratorHandlerInsertion::deliverPoint(const Vector2i& point, bool upper, bool deletionRequired)
{
  if(!deletionRequired)
  {
    std::stringstream line1;
    line1 << "set module:AutomaticCameraCalibrator:insertionCurrentCamera " << (upper ? "upper;" : "lower;");
    robotConsole->handleConsole(line1.str());
    std::stringstream line2;
    line2 << "set module:AutomaticCameraCalibrator:insertionPoint x = ";
    line2 << point.x();
    line2 << "; y = ";
    line2 << point.y();
    line2 << ";";
    robotConsole->handleConsole(line2.str());
    std::stringstream line3;
    line3 << "dr module:AutomaticCameraCalibrator:insertPoint";
    robotConsole->handleConsole(line3.str());
  }
}
Пример #25
0
bool Slider::mouseButtonEvent(const Vector2i &p, int /* button */, bool down, int /* modifiers */) {
    if (!mEnabled)
        return false;
    mValue = std::min(std::max((p.x() - mPos.x()) / (float) mSize.x(), (float) 0.0f), (float) 1.0f);
    if (mCallback)
        mCallback(mValue);
    if (mFinalCallback && !down)
        mFinalCallback(mValue);
    return true;
}
Пример #26
0
void NNUtilities::getInterpolatedImageSection(const Vector2i& center, const Vector2i& inSize, const Vector2i& outSize, const GrayscaledImage& src, OutType* output, const Angle rotation)
{
  Matrix3f inverseTransformation = calcInverseTransformation(center,inSize,outSize, rotation);
  
  if (std::is_same<OutType, float>::value)
    ImageTransform::transform(src, (float*)output, outSize.x(), outSize.y(), inverseTransformation, Vector2f(0.f, 0.f), 128.f);
  else {
    MatrixXf dest(outSize.x(), outSize.y());
    ImageTransform::transform(src, dest.data(), outSize.x(), outSize.y(), inverseTransformation, Vector2f(0.f, 0.f), 128.f);
    Eigen::Matrix<OutType, Eigen::Dynamic, Eigen::Dynamic> dest_ = dest.cast<OutType>();
    memcpy(output, dest_.data(), outSize.x()* outSize.y() * sizeof(OutType));
  }    
}
Пример #27
0
void MotionBlurCamera::setViewport(const Vector2i& size) {
    SceneGraph::Camera3D::setViewport(size);

    /* Initialize previous frames with black color */
    std::size_t textureSize = size.product()*framebuffer.pixelSize();
    Containers::Array<UnsignedByte> texture{Containers::ValueInit, textureSize};
    framebuffer.setData(PixelFormat::RGB8Unorm, size, texture, GL::BufferUsage::DynamicDraw);

    for(Int i = 0; i != FrameCount; ++i)
        frames[i]->setImage(0, GL::TextureFormat::RGB8, framebuffer);
}
Пример #28
0
bool VScrollPanel::mouseDragEvent (const Vector2i &, const Vector2i & rel,
                                   int, int)
{
   if (mChildren.empty())
      return false;
   float scrollh = height() *
                   std::min (1.0f, height() / (float)mChildPreferredHeight);
   mScroll = std::max ((float) 0.0f, std::min ((float) 1.0f,
                       mScroll + rel.y() / (float) (mSize.y() - 8 - scrollh)));
   return true;
}
void AutomaticCameraCalibrator::insertSample(Vector2i point, CameraInfo::Camera camera)
{
  if(insertionOnCamera != theCameraInfo.camera)
    return;
  Sample sample;
  if(!Transformation::imageToRobot(point.x(), point.y(), theCameraMatrix, theCameraInfo, sample.pointOnField))
  {
    OUTPUT_TEXT("MEEEK! Point not on field!" << (theCameraInfo.camera == CameraInfo::upper ? " Upper " : " Lower "));
    return;
  }
  sample.pointInImage = point;
  sample.torsoMatrix = theTorsoMatrix;
  sample.headYaw = theJointAngles.angles[Joints::headYaw];
  sample.headPitch = theJointAngles.angles[Joints::headPitch];
  sample.cameraInfo = theCameraInfo;
  samples.push_back(sample);
  lastInsertedSample = sample;
  lastActionWasInsertion = true;
  alreadyRevertedInsertion = false;
  insertionValueExistant = false;
}
Пример #30
0
Layout Layout::Top(AlignedBox2i box, Dir dir)
{
    Vector2i size = box.sizes();
	switch (dir)
	{
	case Dir::Right:
            return{ dir, Dir::Up, 0, size.x(), size.y(), box.corner(AlignedBox2i::BottomLeft) };
	case Dir::Left:
		return{ dir, Dir::Up, 0, size.x(), size.y(), box.corner(AlignedBox2i::BottomRight) };
	case Dir::Down:
		return{ dir, Dir::Right, 0, size.y(), size.x(), box.corner(AlignedBox2i::TopLeft) };
	case Dir::Up:
		return{ dir, Dir::Right, 0, size.y(), size.x(), box.corner(AlignedBox2i::BottomLeft) };
	default: assert(false && "Layout broken");
		return{};
	}

}