Element Group::invert(const Element& x) const {
#ifdef GROUP_CHECKS_MEMBERSHIP
  if (!contains(x)) throw group_mismatch("Group::invert");
#endif
  return Element(this, inverses[x.val]);
 }

inline Breakpoint* BreakpointTable::get_breakpoint(int32_t location)
{
	assert(contains(location));
	return &(_breakpoints.find(location)->second);
}

/**
 * The DAT format contains "datasets" and each dataset has N-outputs. One output
 * represents data for all vertices/faces for one timestep
 *
 * In MDAL we convert one output to one MDAL dataset;
 *
 */
void MDAL::LoaderAsciiDat::load( MDAL::Mesh *mesh, MDAL_Status *status )
{
  if ( status ) *status = MDAL_Status::None;

  if ( !MDAL::fileExists( mDatFile ) )
  {
    if ( status ) *status = MDAL_Status::Err_FileNotFound;
    return;
  }

  std::ifstream in( mDatFile, std::ifstream::in );
  std::string line;
  if ( !std::getline( in, line ) )
  {
    if ( status ) *status = MDAL_Status::Err_UnknownFormat;
    return;
  }
  line = trim( line );

  // http://www.xmswiki.com/xms/SMS:ASCII_Dataset_Files_*.dat
  // Apart from the format specified above, there is an older supported format used in BASEMENT (and SMS?)
  // which is simpler (has only one dataset in one file, no status flags etc)
  bool oldFormat;
  bool isVector = false;

  std::shared_ptr<DatasetGroup> group; // DAT outputs data
  std::string name( MDAL::baseName( mDatFile ) );

  if ( line == "DATASET" )
    oldFormat = false;
  else if ( line == "SCALAR" || line == "VECTOR" )
  {
    oldFormat = true;
    isVector = ( line == "VECTOR" );

    group.reset( new DatasetGroup() );
    group->uri = mDatFile;
    group->setName( name );
    group->isScalar = !isVector;
  }
  else
    EXIT_WITH_ERROR( MDAL_Status::Err_UnknownFormat );

  // see if it contains face-centered results - supported by BASEMENT
  bool faceCentered = false;
  if ( !oldFormat && contains( name, "_els_" ) )
    faceCentered = true;

  if ( group )
    group->isOnVertices = !faceCentered;

  while ( std::getline( in, line ) )
  {
    std::vector<std::string> items = split( line,  " ", SplitBehaviour::SkipEmptyParts );
    if ( items.size() < 1 )
      continue; // empty line?? let's skip it

    std::string cardType = items[0];
    if ( cardType == "ND" && items.size() >= 2 )
    {
      size_t fileNodeCount = toSizeT( items[1] );
      if ( mesh->vertexIDtoIndex.size() != fileNodeCount )
        EXIT_WITH_ERROR( MDAL_Status::Err_IncompatibleMesh );
    }
    else if ( !oldFormat && cardType == "NC" && items.size() >= 2 )
    {
      size_t fileElemCount = toSizeT( items[1] );
      if ( mesh->faceIDtoIndex.size() != fileElemCount )
        EXIT_WITH_ERROR( MDAL_Status::Err_IncompatibleMesh );
    }
    else if ( !oldFormat && cardType == "OBJTYPE" )
    {
      if ( items[1] != "mesh2d" && items[1] != "\"mesh2d\"" )
        EXIT_WITH_ERROR( MDAL_Status::Err_UnknownFormat );
    }
    else if ( !oldFormat && ( cardType == "BEGSCL" || cardType == "BEGVEC" ) )
    {
      if ( group )
      {
        debug( "New dataset while previous one is still active!" );
        EXIT_WITH_ERROR( MDAL_Status::Err_UnknownFormat );
      }
      isVector = cardType == "BEGVEC";

      group.reset( new DatasetGroup() );
      group->uri = mDatFile;
      group->setName( name );
      group->isScalar = !isVector;
      group->isOnVertices = !faceCentered;
    }
    else if ( !oldFormat && cardType == "ENDDS" )
    {
      if ( !group )
//.........这里部分代码省略.........

bool Rectangle::contains( const Point3d& p3d ) const
{
    return contains(p3d.to_point());
}

std::vector<int> Pathfinder::getPathFrom(int start) const
{
    if (goal_(start)) return {start};

    // Record shortest path costs for every node we examine.
    std::unordered_map<int, AstarNodePtr> nodes;
    // Maintain a heap of nodes to consider.
    std::vector<int> open;
    int goalLoc = -1;
    AstarNodePtr goalNode;

    // The heap functions confusingly use operator< to build a heap with the
    // *largest* element on top.  We want to get the node with the *least* cost,
    // so we have to order nodes in the opposite way.
    auto orderByCost = [&] (int lhs, int rhs)
    {
        return nodes[lhs]->estTotalCost > nodes[rhs]->estTotalCost;
    };

    nodes.emplace(start, make_astar_node(-1, 0, 0));
    open.push_back(start);

    // A* algorithm.  Decays to Dijkstra's if estimate function is always 0.
    while (!open.empty()) {
        auto loc = open.front();
        pop_heap(std::begin(open), std::end(open), orderByCost);
        open.pop_back();
        if (goal_(loc)) {
            goalLoc = loc;
            goalNode = nodes[loc];
            break;
        }

        auto &curNode = nodes[loc];
        curNode->visited = true;
        for (auto n : neighbors_(loc)) {
            auto nIter = nodes.find(n);
            auto step = stepCost_(loc, n);

            if (nIter != nodes.end()) {
                auto &nNode = nIter->second;
                if (nNode->visited) {
                    continue;
                }

                // Are we on a shorter path to the neighbor node than what
                // we've already seen?  If so, update the neighbor's node data.
                if (curNode->costSoFar + step < nNode->costSoFar) {
                    nNode->prev = loc;
                    nNode->costSoFar = curNode->costSoFar + step;
                    nNode->estTotalCost = nNode->costSoFar + estimate_(n);
                    make_heap(std::begin(open), std::end(open), orderByCost);
                }
            }
            else {
                // We haven't seen this node before.  Add it to the open list.
                nodes.emplace(n, make_astar_node(loc, curNode->costSoFar + step, 
                    curNode->costSoFar + step + estimate_(n)));
                open.push_back(n);
                push_heap(std::begin(open), std::end(open), orderByCost);
            }
        }
    }

    if (!goalNode) {
        return {};
    }

    // Build the path from the chain of nodes leading to the goal.
    std::vector<int> path = {goalLoc};
    auto n = goalNode;
    while (n->prev != -1) {
        path.push_back(n->prev);
        n = nodes[n->prev];
    }
    reverse(std::begin(path), std::end(path));
    assert(contains(path, start));
    return path;
}

void do_tokenizing(char *orig, char *source) {
  //printf("***tokenizing...\n------------------------\n%s\n----------------------\n", orig);
  char *str = strdup(orig);

  char *curr, *new_str, *word;
  char *saveptr1, *saveptr2;


  while( (curr = strstr(str, "link:")) != NULL) {
    new_str = strdup(curr+1);

    if(curr == str || (curr > str && is_blank_space(*(curr-1)))) {

      curr = strtok_r(curr, " \n", &saveptr1);
      assert(curr != NULL);

      word = strtok_r(curr, ":", &saveptr2);
      word = strtok_r(NULL, ":", &saveptr2);

      //printf("found word: %s\n", word);
      assert(word != NULL);

      edge_fn(source, word);

      // check hash set and, if not present, add
      // link producer
      Mutex_lock(&l_m);
      while(link_count == max_link) {
	// wait
	Cond_wait(&l_empty, &l_m);
      }
    
      if(!contains(table, word)) {
	// do pushing
	printf("PUSH link: %s\n", word);
	links = push(NULL, strdup(word), links);
	link_count++;
      
	Mutex_lock(&done_m);
	total_work++;
	Mutex_unlock(&done_m);

	printf("--> new link_count: %d\n", link_count);
	printf("--> curr page_count: %d\n", page_count);
	// update table
	add(table, word);
      }
    
      Cond_signal(&l_fill);
      Mutex_unlock(&l_m);

    }

    free(str);
    str = new_str;
  }

  free(str);

  return;
}

	std::shared_ptr<ILoadableObject> ObjLoader::load(AssetManager *assetMgr, AssetInfo &asset)
	{
		shared_ptr<Node> node(new Node());

		std::string currentDir = std::string(asset.getFilePath());
		std::string nodeFileName = currentDir.substr(currentDir.find_last_of("\\/")+1);
		nodeFileName = nodeFileName.substr(0, nodeFileName.find_first_of(".")); // trim extension

		node->setName(nodeFileName);

		std::string line;
		while (std::getline(*asset.getStream(), line))
		{
			vector<string> tokens = split(line, ' ');
			tokens = removeEmptyStrings(tokens);

			if (tokens.size() == 0 || strcmp(tokens[0].c_str(), "#") == 0)
			{
			}
			else if (strcmp(tokens[0].c_str(), "v") == 0)
			{
				float x = parse<float>(tokens[1]);
				float y = parse<float>(tokens[2]);
				float z = parse<float>(tokens[3]);
				Vector3f vec(x, y, z);
				positions.push_back(vec);
			}
			else if (strcmp(tokens[0].c_str(), "vn") == 0)
			{
				float x = parse<float>(tokens[1]);
				float y = parse<float>(tokens[2]);
				float z = parse<float>(tokens[3]);
				Vector3f vec(x, y, z);
				normals.push_back(vec);
			}
			else if (strcmp(tokens[0].c_str(), "vt") == 0)
			{
				float x = parse<float>(tokens[1]);
				float y = parse<float>(tokens[2]);
				Vector2f vec(x, y);
				texCoords.push_back(vec);
			}
			else if (strcmp(tokens[0].c_str(), "f") == 0)
			{
				vector<ObjIndex> *c_idx = currentList();
				for (int i = 0; i < tokens.size() - 3; i++)
				{
					c_idx->push_back(parseObjIndex(tokens[1]));
					c_idx->push_back(parseObjIndex(tokens[2 + i]));
					c_idx->push_back(parseObjIndex(tokens[3 + i]));
				}
			}
			else if (strcmp(tokens[0].c_str(), "mtllib") == 0)
			{
				string libLoc = tokens[1];

				std::string currentDir = std::string(asset.getFilePath());
				currentDir = currentDir.substr(0, currentDir.find_last_of("\\/"));

				if (!contains(currentDir, "/") && !contains(currentDir, "\\"))	// the file path is just current file name,															   
				{																// so just make the string empty
					currentDir = "";
				}

				currentDir += "/" + libLoc;

				std::shared_ptr<MaterialList> mtlList = assetMgr->loadAs<MaterialList>(currentDir.c_str());
				this->mtlList = *mtlList.get();
			}
			else if (strcmp(tokens[0].c_str(), "usemtl") == 0)
			{
				string matname = tokens[1];
				newMesh(matname);
			}
		}

		for (int i = 0; i < objIndices.size(); i++)
		{
			vector<ObjIndex> *c_idx = objIndices[i];
			vector<Vertex> vertices;

			for (int j = 0; j < c_idx->size(); j++)
			{
				Vertex vert(positions[(*c_idx)[j].vertex_idx],
						   (hasTexCoords ? texCoords[(*c_idx)[j].texcoord_idx] : Vector2f()),
						   (hasNormals ? normals[(*c_idx)[j].normal_idx] : Vector3f()));

				vertices.push_back(vert);
			}

			shared_ptr<Mesh> mesh(new Mesh());
			mesh->setVertices(vertices);

			if (hasNormals)
				mesh->getAttributes().setAttribute(VertexAttributes::NORMALS);
			if (hasTexCoords)
				mesh->getAttributes().setAttribute(VertexAttributes::TEXCOORDS0);

			shared_ptr<Geometry> geom(new Geometry());
			geom->setName(names[i]);
//.........这里部分代码省略.........

//Traverse a directory tree with root given by 'path'
void traverse(char* path, char* str, int log_out, int grep_out, list* checked){
	DIR *pDir;
	struct dirent *pDirent;
	struct stat s;
	pid_t child;
	int status;
	int text;

	pDir = opendir(path);
	//Iterate through the contents of the current directory
	while((pDirent = readdir(pDir)) != NULL){
		char* current_path;
		char* current;

		if((current_path = malloc(512*sizeof(char))) == NULL){
			fprintf(stderr, "ERROR: malloc() error\n");
			exit(0);
		}
		//Construct the path string
		current = pDirent->d_name;
		strcpy(current_path, path);
		strcat(current_path, "/");
		strcat(current_path, current);
		//Ignore '.' and '..' directories
		if(!strcmp(current, ".") || !strcmp(current, "..")){
			continue;
		}
		//Write paths to log.txt
		write(log_out, current_path, strlen(current_path));
		write(log_out, "\n", 1);
		//Check for redundant links
		if(lstat(current_path, &s) != 0){
			fprintf(stderr, "ERROR: lstat() failure\n");
		}
		else if(!contains(checked, (int)s.st_ino)){
			insert(checked, (int)s.st_ino);
		}
		else{
			continue;
		}

		//Check if the current file is a directory
		if(S_ISDIR(s.st_mode)){
				traverse(current_path, str, log_out, grep_out, checked);				
		}//If not, fork
		else{
			int pp[2];
			int size = s.st_size;
			char buf[size];

			if(pipe(pp) == -1){//Create a pipe
				fprintf(stderr, "ERROR: pipe() failure\n");
			}
			dup2(grep_out, 1);
			dup2(pp[0], 0);
			
			child = fork();
			if(child == -1){
				fprintf(stderr, "ERROR: fork() failure\n");
				exit(0);
			}

			if(child == 0){//The child executes grep
				close(pp[1]);
				char* array[3] = {"grep", str, NULL};
				execvp(array[0], array);
			}
			else{//The parent pipes the text to the child
				close(pp[0]);
				text = open(current_path, O_RDONLY);
				read(text, buf, size);
				write(pp[1], buf, size);
				close(pp[1]);
				wait(NULL);
			}
		}
		free(current_path);
	}
	closedir(pDir);
}

inline address ThreadCodeBuffer::compute_adjusted_pc(address pc) {
  assert(contains(pc), "pc must point into codebuffer") 
  pc = real_pc() + (pc - code_begin());
  assert(method()->contains(pc), "result must be in nmethod");      
  return pc;
}

int main(int argc, char *argv[])
{
    int size,tmpdec,i,fd, nread, fp, ntemp, tmpi,colons, uid,tmpflag;
    double tmpsize;
    long long int giga,mega,kilo;
    giga=1024*1024*1024;
    mega=1024*1024;
    kilo=1024;
    char buf[BUF_SIZE];
    char user[50];
    char buffer[50000],linkval[500];
    char line[1000];
    struct linux_dirent *d;
    int bpos,isalink;
    int flag=0,hasfile=0;
    char d_type;
    int l=0,a=0,h=0;
    struct stat fileStat,tmpStat;
    char file[100],tmpfile[100];
    if(argc==2||argc==3)
    {
        if(compare(argv[1],"-l")||compare(argv[1],"-a")||compare(argv[1],"-h")||compare(argv[1],"-lah")||compare(argv[1],"-lha")||compare(argv[1],"-ahl")||compare(argv[1],"-alh")||compare(argv[1],"-hla")||compare(argv[1],"-hal")||compare(argv[1],"-la")||compare(argv[1],"-ah")||compare(argv[1],"-hl")||compare(argv[1],"-al")||compare(argv[1],"-ha")||compare(argv[1],"-lh"))
        {
            flag=1;
            if(argc>2)
                hasfile=1;
            if(contains(argv[1],'l'))
                l=1;
            if(contains(argv[1],'a'))
            {
                if(l==0)
                    flag=0;
                if(argc==3)
                    hasfile=1;
                a=1;
            }
            if(contains(argv[1],'h'))
            {
                h=1;
                if(l==0)
                    flag=0;
                if(argc==3)
                    hasfile=1;
            }
        }
        else if(argc==2)
            hasfile=1;
    }
    if(argc==3)
    {
        if(compare(argv[2],"-l")||compare(argv[2],"-a")||compare(argv[2],"-h")||compare(argv[2],"-lah")||compare(argv[2],"-lha")||compare(argv[2],"-ahl")||compare(argv[2],"-alh")||compare(argv[2],"-hla")||compare(argv[2],"-hal")||compare(argv[2],"-la")||compare(argv[2],"-ah")||compare(argv[2],"-hl")||compare(argv[2],"-al")||compare(argv[2],"-ha")||compare(argv[2],"-lh"))
        {
            flag=2;
            hasfile=1;
            if(contains(argv[2],'l'))
                l=1;
            if(contains(argv[2],'a'))
            {
                a=1;
                if(l==0)
                    flag=0;
            }
            if(contains(argv[2],'h'))
            {
                h=1;
                if(l==0)
                    flag=0;
            }
        }
    }
    //	printf("%d %d %d %d %d %d\n" ,l,a,h,hasfile,flag, argc);
    if((!flag&&a&!l)||(!flag&&h&!l)||!a&!l&!h||(!flag&&a&h))
    {
        if(argc>1)
        {
            file[0]='\0';
            if(!a&&!h)
            {
                fd = open(argv[1], O_RDONLY | O_DIRECTORY);
                concat(file,argv[1]);
                //printf("%s",file);
            }
            else if(a|h)
            {
                if(hasfile)
                {
                    if(compare(argv[1],"-a")||compare(argv[1],"-h")||compare(argv[1],"-ah")||compare(argv[1],"-ha"))
                    {
                        fd = open(argv[2], O_RDONLY | O_DIRECTORY);
                        concat(file,argv[2]);
                    }
                    else if(compare(argv[2],"-a")||compare(argv[2],"-h")||compare(argv[2],"-ah")||compare(argv[2],"-ha"))
                    {
                        fd = open(argv[1], O_RDONLY | O_DIRECTORY);
                        concat(file,argv[1]);
                    }
                    //fd = open(".", O_RDONLY | O_DIRECTORY);
                }
                else
                {
//.........这里部分代码省略.........

void Joystick::handleEvent(sf::Event const& event, const sf::Vector2f& position)
{
	if ((event.type == sf::Event::TouchBegan || (event.type == sf::Event::MouseButtonPressed && event.mouseButton.button == sf::Mouse::Left)) && contains(position))
    {
        mHeld = true;
		if (ke::isMobile())
		{
			mFingerId = event.touch.finger;
		}
        mButton.setPosition(0,0);
    }
    if ((event.type == sf::Event::MouseButtonReleased && event.mouseButton.button == sf::Mouse::Left) || (event.type == sf::Event::TouchEnded && event.touch.finger == mFingerId))
    {
        mHeld = false;
        mButton.setPosition(0,0);
    }
    if ((event.type == sf::Event::MouseMoved || (event.type == sf::Event::TouchMoved && event.touch.finger == mFingerId)) && mHeld)
    {
        sf::Vector2f p = position - getPosition();
		if (mBlockHorizontal)
		{
			p.x = 0.f;
		}
		if (mBlockVertical)
		{
			p.y = 0.f;
		}
        float r = std::sqrt(p.x * p.x + p.y * p.y);
        if (r >= mDeltaMax)
        {
            mButton.setPosition(mDeltaMax * sf::Vector2f(p.x/r,p.y/r));
        }
        else
        {
            mButton.setPosition(p);
        }
    }
}

bool
Interval::contains(const Interval* interval) const
{
    return contains(interval->min, interval->max);
}

 string Group::showElem(const Element& x) const {
#ifdef GROUP_CHECKS_MEMBERSHIP
  if (!contains(x)) throw group_mismatch("Group::showElem");
#endif
  return strs[x.val];
 }

 int Group::order(const Element& x) const {
#ifdef GROUP_CHECKS_MEMBERSHIP
  if (!contains(x)) throw group_mismatch("Group::order");
#endif
  return orders[x.val];
 }

 bool get(const K & k, V & v) {
   if(contains(k)) {
     v = kvdct.at(k);
     return true;
   } else { return false; }
 }

 paracel::Enable_if<paracel::is_atomic<T>::value, bool>
 incr(const K & k, const T & delta) {
   if(!contains(k)) return false;
   kvdct[k] += delta;
   return true;
 }

Scene SceneBuilder::BuildScene(World& world, Camera& camera, const std::unordered_map<int, AdditionalStepParameters>& additionalParameters)
{
    Scene scene;
    std::vector<std::vector<ObjectHint>> hints;

    for (DrawableWorldObject& obj : world.GetDrawableObjects())
    {
        for (const Mesh& mesh : obj.GetMeshes())
        {
            Mat4 camMat = camera.GetCameraMatrix();
            Mat4 perspMat = camera.GetPerspectiveMatrix();
            Mat4 posMat = obj.GetPositionMatrix();
            Mat4 rotMat = obj.GetRotation();
            Vec3 camPosition = camera.GetPosition();
            Mat4 pMatrix = perspMat * camMat;
            MaterialProperties properties = mesh.GetMaterialProperties();
            int tiling = obj.GetTiling();
            bool aoTiling = obj.IsAoTiling();

            ShaderConfiguration c;
            c = [=]
            {
                for (auto& step : steps)
                {
                    for (auto& p : step.first.renderStep.shaders)
                    {
                        p.get().SetUniform(camPosition, "camPosition");
                        p.get().SetUniform(camMat, "WtoCMatrix");
                        p.get().SetUniform(perspMat, "perspective");
                        p.get().SetUniform(posMat, "MtoWMatrix");
                        p.get().SetUniform(rotMat, "rotation");
                        p.get().SetUniform(pMatrix, "pMatrix");
                        p.get().SetUniform(tiling, "tilingFactor");
                        p.get().SetUniform(properties.roughnessMap, "roughnessTex");
                        p.get().SetUniform(properties.aoMap, "aoTex");
                        p.get().SetUniform(properties.albedoTexture, "albedoTex");
                        p.get().SetUniform(properties.metallnessMap, "metallnessTex");
                        p.get().SetUniform(properties.roughness, "roughness");
                        p.get().SetUniform(properties.ao, "ao");
                        p.get().SetUniform(properties.albedo, "albedo");
                        p.get().SetUniform(properties.metallness, "metallness");
                        p.get().SetUniform(properties.normalMap, "normalTex");
                        p.get().SetUniform(properties.inverseRoughness, "inverseRoughness");
                        p.get().SetUniform(aoTiling, "aoTiling");
                    }
                }
            };

            scene.meshes.emplace_back(mesh, c);
            hints.emplace_back(obj.GetHints());
        }
    }

    int i = 0;

    for (auto& step : steps)
    {
        AdditionalStepParameters params;

        if (additionalParameters.count(i))
            params = additionalParameters.at(i);

        if (step.first.isMultiStep)
        {
            for (int j = 0; j < step.first.stepCount(world); j++)
            {
                step.first.processor(world, step.first.renderStep, i, j, params);
                scene.path.steps.push_back(step.first.renderStep);
                i++;
            }
        }
        else
        {
            step.first.processor(world, step.first.renderStep, i, 0, params);
            scene.path.steps.push_back(step.first.renderStep);
            i++;
        }
    }

    i = 0;
    for (MeshDescriptor& obj : scene.meshes)
    {
        int j = 0;
        for (auto& step : steps)
        {
            if (step.first.isMultiStep)
            {
                for (int k = 0; k < step.first.stepCount(world); k++, j++)
                {
                    if (step.second.empty() || contains(hints[i], step.second))
                        scene.path.steps[j].objects.push_back(i);
                }
            }
            else
            {
                if (step.second.empty() || contains(hints[i], step.second))
                    scene.path.steps[j].objects.push_back(i);
                j++;
            }
        }
//.........这里部分代码省略.........

bool String::contains(String& sequence)
{
    return contains(*sequence);
}

dtStatus dtTileCache::update(const float /*dt*/, dtNavMesh* navmesh)
{
	if (m_nupdate == 0)
	{
		// Process requests.
		for (int i = 0; i < m_nreqs; ++i)
		{
			ObstacleRequest* req = &m_reqs[i];
			
			unsigned int idx = decodeObstacleIdObstacle(req->ref);
			if ((int)idx >= m_params.maxObstacles)
				continue;
			dtTileCacheObstacle* ob = &m_obstacles[idx];
			unsigned int salt = decodeObstacleIdSalt(req->ref);
			if (ob->salt != salt)
				continue;
			
			if (req->action == REQUEST_ADD)
			{
				// Find touched tiles.
				float bmin[3], bmax[3];
				getObstacleBounds(ob, bmin, bmax);

				int ntouched = 0;
				queryTiles(bmin, bmax, ob->touched, &ntouched, DT_MAX_TOUCHED_TILES);
				ob->ntouched = (unsigned char)ntouched;
				// Add tiles to update list.
				ob->npending = 0;
				for (int j = 0; j < ob->ntouched; ++j)
				{
					if (m_nupdate < MAX_UPDATE)
					{
						if (!contains(m_update, m_nupdate, ob->touched[j]))
							m_update[m_nupdate++] = ob->touched[j];
						ob->pending[ob->npending++] = ob->touched[j];
					}
				}
			}
			else if (req->action == REQUEST_REMOVE)
			{
				// Prepare to remove obstacle.
				ob->state = DT_OBSTACLE_REMOVING;
				// Add tiles to update list.
				ob->npending = 0;
				for (int j = 0; j < ob->ntouched; ++j)
				{
					if (m_nupdate < MAX_UPDATE)
					{
						if (!contains(m_update, m_nupdate, ob->touched[j]))
							m_update[m_nupdate++] = ob->touched[j];
						ob->pending[ob->npending++] = ob->touched[j];
					}
				}
			}
		}
		
		m_nreqs = 0;
	}
	
	// Process updates
	if (m_nupdate)
	{
		// Build mesh
		const dtCompressedTileRef ref = m_update[0];
		dtStatus status = buildNavMeshTile(ref, navmesh);
		m_nupdate--;
		if (m_nupdate > 0)
			memmove(m_update, m_update+1, m_nupdate*sizeof(dtCompressedTileRef));

		// Update obstacle states.
		for (int i = 0; i < m_params.maxObstacles; ++i)
		{
			dtTileCacheObstacle* ob = &m_obstacles[i];
			if (ob->state == DT_OBSTACLE_PROCESSING || ob->state == DT_OBSTACLE_REMOVING)
			{
				// Remove handled tile from pending list.
				for (int j = 0; j < (int)ob->npending; j++)
				{
					if (ob->pending[j] == ref)
					{
						ob->pending[j] = ob->pending[(int)ob->npending-1];
						ob->npending--;
						break;
					}
				}
				
				// If all pending tiles processed, change state.
				if (ob->npending == 0)
				{
					if (ob->state == DT_OBSTACLE_PROCESSING)
					{
						ob->state = DT_OBSTACLE_PROCESSED;
					}
					else if (ob->state == DT_OBSTACLE_REMOVING)
					{
						ob->state = DT_OBSTACLE_EMPTY;
						// Update salt, salt should never be zero.
						ob->salt = (ob->salt+1) & ((1<<16)-1);
						if (ob->salt == 0)
							ob->salt++;
//.........这里部分代码省略.........

bool FloatRect::contains(const FloatPoint& point, ContainsMode containsMode) const
{
    if (containsMode == InsideOrOnStroke)
        return contains(point.x(), point.y());
    return x() < point.x() && maxX() > point.x() && y() < point.y() && maxY() > point.y();
}