Пример #1
0
  bool PixelMap::isCollision(const RasterMap &rastermap, const IntPoint &pos1, const IntPoint &pos2, const IntRect &rect1, const IntRect &rect2, const Alignment &alignment1, const Alignment &alignment2) const
  {
    int fpx, fpy; /* First pixel to check */
    int lpx, lpy; /* Last pixel to check */
    int frx, fry; /* First pixel relative to rastermap */
    IntPoint corner1(pos1), corner2(pos2);
    IntRect framerect1, framerect2;
    IntRect mrect1, mrect2;
    IntRect *cutrect;


    /* Break */
      if(map == NULL)
        return false;


    /* Translate negative axises */
      mrect1 = rect_translate_negative_axises(rect1, size);
      mrect2 = rect_translate_negative_axises(rect2, rastermap.getMapSize() * rastermap.getCellSize());


    /* Align */
      if(alignment1.getX() != 0) corner1.decX((int)(mrect1.getWidth() * alignment1.getX()));
      if(alignment1.getY() != 0) corner1.decY((int)(mrect1.getHeight() * alignment1.getY()));
      if(alignment2.getX() != 0) corner2.decX((int)(mrect2.getWidth() * alignment2.getX()));
      if(alignment2.getY() != 0) corner2.decY((int)(mrect2.getHeight() * alignment2.getY()));


    /* Framerects */
      framerect1.load(corner1.getX(), corner1.getY(), mrect1.getWidth(), mrect1.getHeight());
      framerect2.load(corner2.getX(), corner2.getY(), mrect2.getWidth(), mrect2.getHeight());


    /* Break */
      if(!size_to_rect(size).isCovering(mrect1))
        throw Exception() << "pixelmap doesn't fully cover rect";
      if(!size_to_rect(rastermap.getMapSize() * rastermap.getCellSize()).isCovering(mrect2))
        throw Exception() << "rastermap doesn't fully cover rect";


   /* Cutrect */
      if((cutrect = framerect1.getCutrect(framerect2)) == NULL)
        return false;


    /* First / last pixel to check on pixelmap */
      fpx = cutrect->getX() - (corner1.getX() - mrect1.getX());
      fpy = cutrect->getY() - (corner1.getY() - mrect1.getY());

      lpx = fpx + cutrect->getWidth() - 1;
      lpy = fpy + cutrect->getHeight() - 1;


    /* Get first pixel relative to rastermap */
      frx = cutrect->getX() - (corner2.getX() - mrect2.getX());
      fry = cutrect->getY() - (corner2.getY() - mrect2.getY());


    /* Delete cutrect */
      delete cutrect;


    /* Iterate pixels */
      for(int py = fpy, ry = fry; py <= lpy; py++, ry++)
      {
        for(int px = fpx, rx = frx; px <= lpx; px++, rx++)
        {
          if(is_pixel(px, py))
          {
            int cx, cy;

            /* Get cell */
              cx = rx / rastermap.getCellSize().getWidth();
              cy = ry / rastermap.getCellSize().getHeight();

            /* Check */
              if(rastermap.isCell(IntPoint(cx, cy)))
              {
                return true;
              }
              else
              {
                int add = rastermap.getCellSize().getWidth() - (rx % rastermap.getCellSize().getWidth());
                  rx += add;
                  px += add;
              }
          }

        }
      }



    return false;
  }
Пример #2
0
  bool PixelMap::isCollision(const PixelMap &pixelmap2, const IntPoint &pos1, const IntPoint &pos2, const geo::IntRect &rect1, const geo::IntRect &rect2, const Alignment &alignment1, const Alignment &alignment2) const
  {
    int fp1x, fp1y, fp2x, fp2y; /* First pixel to check */
    int cw, ch; /* Sizes of the rect to check on both maps */
    IntPoint corner1(pos1), corner2(pos2);
    IntRect mrect1, mrect2;
    IntRect framerect1, framerect2;
    IntRect *cutrect;


    /* Break */
      if(map == NULL)
        return false;


    /* Translate negative axises */
      mrect1 = rect_translate_negative_axises(rect1, size);
      mrect2 = rect_translate_negative_axises(rect2, pixelmap2.size);


    /* Align */
      if(alignment1.getX() != 0) corner1.decX((int)(mrect1.getWidth() * alignment1.getX()));
      if(alignment1.getY() != 0) corner1.decY((int)(mrect1.getHeight() * alignment1.getY()));
      if(alignment2.getX() != 0) corner2.decX((int)(mrect2.getWidth() * alignment2.getX()));
      if(alignment2.getY() != 0) corner2.decY((int)(mrect2.getHeight() * alignment2.getY()));


    /* Framerects */
      framerect1.load(corner1.getX(), corner1.getY(), mrect1.getWidth(), mrect1.getHeight());
      framerect2.load(corner2.getX(), corner2.getY(), mrect2.getWidth(), mrect2.getHeight());



    /* Break */
      if(!IntRect(0, 0, size.getWidth(), size.getHeight()).isCovering(mrect1))
        throw Exception() << "pixelmap1 doesn't fully cover rect";
      if(!IntRect(0, 0, pixelmap2.size.getWidth(), pixelmap2.size.getHeight()).isCovering(mrect2))
        throw Exception() << "pixelmap2 doesn't fully cover rect";


    /* Cutrect */
      if((cutrect = framerect1.getCutrect(framerect2)) == NULL)
        return false;


    /* Get first pixels and size to check */
      cw = cutrect->getWidth();
      ch = cutrect->getHeight();
      fp1x = cutrect->getX() - (framerect1.getX() - mrect1.getX());
      fp1y = cutrect->getY() - (framerect1.getY() - mrect1.getY());
      fp2x = cutrect->getX() - (framerect2.getX() - mrect2.getX());
      fp2y = cutrect->getY() - (framerect2.getY() - mrect2.getY());

      /* Delete cutrect */
        delete cutrect;


    /* Compare Pixels */
      for(int py = 0; py < ch; py++)
      {
        for(int px = 0; px < cw; px++)
        {
          if(is_pixel_on_map(map, px + fp1x, py + fp1y) && is_pixel_on_map(pixelmap2.map, px + fp2x, py + fp2y))
            return true;
        }
      }


    /* No collision detected */
      return false;
  }
Пример #3
0
  bool PixelMap::isCollision(const RectMap &rectmap, const IntPoint &pos1, const IntPoint &pos2, const IntRect &rect1, const IntRect &rect2, const Alignment &alignment1, const Alignment &alignment2) const
  {
    IntPoint corner1(pos1), corner2(pos2);
    IntRect framerect1, framerect2;
    IntRect mrect1, mrect2;
    IntRect *cutrect;


    /* Break */
      if(map == NULL)
        return false;


    /* Translate negative axises */
      mrect1 = rect_translate_negative_axises(rect1, size);
      mrect2 = rect_translate_negative_axises(rect2, rectmap.getSize());


    /* Align */
      if(alignment1.getX() != 0) corner1.decX((int)(mrect1.getWidth() * alignment1.getX()));
      if(alignment1.getY() != 0) corner1.decY((int)(mrect1.getHeight() * alignment1.getY()));
      if(alignment2.getX() != 0) corner2.decX((int)(mrect2.getWidth() * alignment2.getX()));
      if(alignment2.getY() != 0) corner2.decY((int)(mrect2.getHeight() * alignment2.getY()));


    /* Framerects */
      framerect1.load(corner1.getX(), corner1.getY(), mrect1.getWidth(), mrect1.getHeight());
      framerect2.load(corner2.getX(), corner2.getY(), mrect2.getWidth(), mrect2.getHeight());


    /* Break */
      if(!size_to_rect(size).isCovering(mrect1))
        throw Exception() << "pixelmap1 doesn't fully cover rect";


    /* Cutrect */
      if((cutrect = framerect1.getCutrect(framerect2)) == NULL)
        return false;


    /* Iterate rects, check pixels */
      for(int r = 0; r < rectmap.getRectCount(); r++)
      {
        int fpx, fpy; /* First pixel to check */
        int lpx, lpy; /* Last pixel to check */

        IntRect srect = rectmap.getRect(r) + point_to_vector(corner2) - IntVector(mrect2.getX(), mrect2.getY());
        IntRect *scutrect;


        /* Clip with cutrect*/
          if((scutrect = srect.getCutrect(*cutrect)) == NULL)
            continue;


        /* Pixels to check */
          fpx = scutrect->getX() - (corner1.getX() - mrect1.getX());
          fpy = scutrect->getY() - (corner1.getY() - mrect1.getY());
          lpx = fpx + scutrect->getWidth() - 1;
          lpy = fpy + scutrect->getHeight() - 1;


        /* Check pixels */
          for(int py = fpy; py <= lpy; py++)
          {
            for(int px = fpx; px <= lpx; px++)
            {
              if(is_pixel(px, py))
              {
                /* Free mem */
                  delete cutrect;
                  delete scutrect;

                /* Collision detected */
                  return true;
              }
            }
          }

        delete scutrect;
      }

    delete cutrect;


    return false;

  }
Пример #4
0
  bool RasterMap::isCollision(const RasterMap &rastermap2, const IntPoint &pos1, const IntPoint &pos2,const IntRect &rect1, const IntRect &rect2, const etc::Alignment &alignment1, const etc::Alignment &alignment2) const
  {
    int br, bb;
    int rm1x, rm1y, rm2x, rm2y;
    int fr1x, fr1y, fr2x, fr2y;
    int fc1x, fc1y, lc1x, lc1y;
    int fc2x, fc2y, lc2x, lc2y;
    IntPoint corner1(pos1), corner2(pos2);
    IntRect framerect1, framerect2;
    IntRect mrect1, mrect2;
    IntRect *cutrect;



    /* Align */
      if(alignment1.getX() != 0) corner1.decX((int)(mrect1.getWidth() * alignment1.getX()));
      if(alignment1.getY() != 0) corner1.decY((int)(mrect1.getHeight() * alignment1.getY()));
      if(alignment2.getX() != 0) corner2.decX((int)(mrect2.getWidth() * alignment2.getX()));
      if(alignment2.getY() != 0) corner2.decY((int)(mrect2.getHeight() * alignment2.getY()));


    /* Framerects */
      framerect1.load(corner1.getX(), corner1.getY(), mrect1.getWidth(), mrect1.getHeight());
      framerect2.load(corner2.getX(), corner2.getY(), mrect2.getWidth(), mrect2.getHeight());


    /* Break */
      if(cellsize == 0 || rastermap2.cellsize == 0)
        return false;
      if(mapsize == 0 || rastermap2.mapsize == 0)
        return false;


    /* Clipping check */
      if(!size_to_rect(mapsize * cellsize).isCovering(mrect1))
        throw Exception() << "rastermap1 doesnt fully cover rect";
      if(!size_to_rect(rastermap2.mapsize * rastermap2.cellsize).isCovering(mrect2))
        throw Exception() << "rastermap2 doesnt fully cover rect";


    /* Get cutrect */
      if((cutrect = framerect1.getCutrect(framerect2)) == NULL)
        return false;


    /* Corners of both rastermaps */
      rm1x = corner1.getX() - mrect1.getX();
      rm1y = corner1.getY() - mrect1.getY();
      rm2x = corner2.getX() - mrect2.getX();
      rm2y = corner2.getY() - mrect2.getY();


    /* First pixel of cutrect relative to map */
      fr1x = cutrect->getX() - rm1x;
      fr1y = cutrect->getY() - rm1y;
      fr2x = cutrect->getX() - rm2x;
      fr2y = cutrect->getY() - rm2y;


    /* First/last cell */
      fc1x = fr1x / cellsize.getWidth();
      fc1y = fr1y / cellsize.getHeight();
      lc1x = (fr1x + cutrect->getWidth() - 1) / cellsize.getWidth();
      lc1y = (fr1y + cutrect->getHeight() - 1) / cellsize.getHeight();


    /* Borders of last cell on second rastermap that are still covered by rm1 */
    /* Not needed if axis is 0 */
      if(lc1x != fc1x)
        br = cellsize.getWidth() - ((lc1x - fc1x + 1) * cellsize.getWidth() - cutrect->getWidth() - (fr1x - fc1x * cellsize.getWidth()));
      else
        br = 0; // To avoid warnings

      if(lc1y != fc1y)
        bb = cellsize.getHeight() - ((lc1y - fc1y + 1) * cellsize.getHeight() - cutrect->getHeight() - (fr1y - fc1y * cellsize.getHeight()));
      else
        bb = 0; // To avoid warnings


    /* Iterate cells */
      for(int cy = fc1y, rgy = cutrect->getY() - rm2y; cy <= lc1y; cy++)
      {
        for(int cx = fc1x, rgx = cutrect->getX() - rm2x; cx <= lc1x; cx++)
        {

          if(is_cell(cx, cy))
          {
            /* Get checking range */
              fc2x = rgx / rastermap2.cellsize.getWidth();
              fc2y = rgy / rastermap2.cellsize.getHeight();

              if(cx == lc1x)
              {
                if(cx == fc1x)
                  lc2x = (rgx + cutrect->getWidth()) / rastermap2.cellsize.getWidth();
                else
                  lc2x = (rgx + br) / rastermap2.cellsize.getWidth();
              }
              else
                lc2x = (rgx + cellsize.getWidth()) / rastermap2.cellsize.getWidth();

              if(cy == lc1y)
              {
                if(cy == fc1y)
                  lc2y = (rgy + cutrect->getHeight()) / rastermap2.cellsize.getHeight();
                else
                  lc2y = (rgy + bb) / rastermap2.cellsize.getHeight();
              }
              else
                lc2y = (rgy + cellsize.getHeight()) / rastermap2.cellsize.getHeight();


            /* Do checking */
              for(int cy = fc2y; cy <= lc2y; cy++)
              {
                for(int cx = fc2x; cx <= lc2x; cx++)
                {
                  if(rastermap2.map[cy][cx>>3] & (1 << (cx%8)))
                  {
                    delete cutrect;
                    return true;
                  }

                }
              }

          }

          /* Inc iterator */
            if(cx == fc1x)
              rgx += cellsize.getWidth() - fr1x%cellsize.getWidth();
            else
              rgx += cellsize.getWidth();
        }


        /* Inc iterator */
          if(cy == fc1y)
            rgy += cellsize.getHeight() - fr1y%cellsize.getHeight();
          else
            rgy += cellsize.getHeight();
      }


    /* Delete cutrect */
      delete cutrect;

    return false;
  }