コード例 #1
0
void AseLoader::Process_MESH_FACE_LIST(IN std::vector<D3DXVECTOR3>& pos, OUT std::vector<FVF_PositionNormalTexture>& vertex)
{
	int level = 0;
	do 
	{
		char* aseToken = GetToken();
		if (IsEqual(aseToken, "{"))
		{
			level++;
		}
		else if (IsEqual(aseToken, "}"))
		{
			level--;
		}
		else if (IsEqual(aseToken, ID_MESH_FACE))
		{		
			//
			//*MESH_FACE    0:    A : 0 B : 1 C : 2 AB : 1 BC : 1 CA : 1
			int index = GetInteger();
			GetToken();
			int a = GetInteger();
			GetToken();
			int b = GetInteger();
			GetToken();
			int c = GetInteger();

			vertex[index * 3 + 0].pos = pos[a];
			vertex[index * 3 + 1].pos = pos[c];
			vertex[index * 3 + 2].pos = pos[b];
		}
	} while (level > 0);
}
コード例 #2
0
bool CGlobalVars::info_single_limper()
{
	/*
	*  return true if there is a single limper
	* Example:
	*  -true: I'm Bigblind, SB fold and other player limped
	*  -true: I'm Bigblind, SB limped and the rest fold
	*/

	if (br==1)
	{
		if(SB)
		{
			//SB posted (2*bblind+1*sblind)
			if(IsEqual(get_potplayer(), (get_sblind() + get_bblind() + get_bblind())))
				return true;

			if(set_preflop_position() == 2 && IsEqual(get_potplayer(), (get_bblind() + get_bblind())))
				return true;
		}
		else
		{
			//no SB (2*bblind)
			if(IsEqual(get_potplayer(), get_bblind() + get_bblind()))
				return true;
		}
	}

	return false;
}
コード例 #3
0
bool IsEqual(const pvdb::ConceptMap& lhs, const pvdb::ConceptMap& rhs)
{
  //Compare nodes
  {
    const std::vector<boost::shared_ptr<const pvdb::Node> > lhs_nodes = lhs.GetNodes();
    const std::vector<boost::shared_ptr<const pvdb::Node> > rhs_nodes = rhs.GetNodes();
    if (lhs_nodes.size() != rhs_nodes.size()) return false;
    const int n_nodes = static_cast<int>(lhs_nodes.size());
    for (int i=0; i!=n_nodes; ++i)
    {
      if (!IsEqual(*lhs_nodes[i],*rhs_nodes[i])) return false;
    }
  }
  //Compare edges
  {
    const std::vector<boost::shared_ptr<const pvdb::Edge> > lhs_edges = lhs.GetEdges();
    const std::vector<boost::shared_ptr<const pvdb::Edge> > rhs_edges = rhs.GetEdges();
    if (lhs_edges.size() != rhs_edges.size()) return false;
    const int n_edges = static_cast<int>(lhs_edges.size());
    for (int i=0; i!=n_edges; ++i)
    {
      if (!IsEqual(*lhs_edges[i],*rhs_edges[i])) return false;
    }
  }
  return true;

}
コード例 #4
0
CShape3D::Num CAABB::Dist2Line(const CVector<3, Num> &vMin, const CVector<3, Num> &vMax,
                               const CVector<3, Num> &vPoint0, const CVector<3, Num> &vPoint1, Num nLineMin, Num nLineMax)
{
  CVector<3, Num> vLine;
  int i, j;
  Num nDist, nFactor;

  vLine = vPoint1 - vPoint0;
  if (IsEqual(vLine.LengthSqr(), 0))
    return Dist2Point(vMin, vMax, vPoint0);
  // Check for intersections with the sides
  for (i = 0; i < 3; i++) {
    if (IsEqual(vLine[i], 0)) { // Line is parallel to the AABB sides in this dimension
      if (vPoint0[i] >= vMin[i] && vPoint0[i] <= vMax[i]) // Coordinate is within bounds, continue checking the other dimensions
        continue;
      break; // Line can't intersect the AABB
    }
    if (TestLineCoordinate(vMin, vMax, vPoint0, vLine, nLineMin, nLineMax, vMin[i], i, nFactor)) // Line intersects the Min plane of the dimension inside the AABB side
      return 0;
    if (TestLineCoordinate(vMin, vMax, vPoint0, vLine, nLineMin, nLineMax, vMax[i], i, nFactor)) // Line intersects the Max plane of the dimension inside the AABB side
      return 0;
  }
  // No side intersections found, check AABB edges for the least distance to the line
  nDist = Util::F_INFINITY;
  for (i = 0; i < 3; i++)
    for (j = 0; j < 4; j++) {
      Num nEdgeDist = Edge2LineDist(vMin, vMax, i, j, vPoint0, vPoint1, nLineMin, nLineMax);
      if (nDist > nEdgeDist)
        nDist = nEdgeDist;
    }
  return nDist;
}
コード例 #5
0
void AseLoader::Process_MATERIAL_LIST()
{
	int level = 0;
	do 
	{
		char* aseToken = GetToken();
		if (IsEqual(aseToken, "{"))
		{
			level++;
		}
		else if (IsEqual(aseToken, "}"))
		{
			level--;
		}
		else if (IsEqual(aseToken, ID_MATERIAL_COUNT))
		{
			materialTextures.resize(GetInteger());
		}
		else if (IsEqual(aseToken, ID_MATERIAL))
		{
			int mtRef = GetInteger();
			materialTextures[mtRef] = new MaterialTexture;
			Process_MATERIAL(materialTextures[mtRef]);
		}
	} while ( level > 0 );
}
コード例 #6
0
void AseLoader::Process_MESH_VERTEX_LIST( OUT std::vector<D3DXVECTOR3>& pos )
{
	int level = 0;
	do 
	{
		char* aseToken = GetToken();
		if (IsEqual(aseToken, "{"))
		{
			level++;
		}
		else if (IsEqual(aseToken, "}"))
		{
			level--;
		}
		else if (IsEqual(aseToken, ID_MESH_VERTEX))
		{		
			//
			int index = GetInteger();
			float x = GetFloat();
			float z = GetFloat();
			float y = GetFloat();

			pos[index] = D3DXVECTOR3(x, y, z);
		}
	} while (level > 0);
}
コード例 #7
0
ファイル: PCFPipesMgr.cpp プロジェクト: uesoft/AutoPFA
void PCFPipesMgr::CombinationPipe(AcGePoint3d &Pt1,AcGePoint3d &Pt2)
{
	PCFPipe *pPipe = NULL;
	PCFPipe *pPipe1 = NULL;
	PCFPipe *pPipe2 = NULL;
	IteratorPtr<PCFPipe> PipeitPtr(CreateIt());
	for(PipeitPtr->Fist();!PipeitPtr->IsDone();PipeitPtr->Next())
	{
		pPipe = &PipeitPtr->CurrentItem();
		ASSERT(pPipe != NULL);
		if(IsEqual(pPipe->EndPt(),Pt1))
		{
			pPipe1 = pPipe;
		}
		if(IsEqual(pPipe->StartPt(),Pt2))
		{
			pPipe2 = pPipe;
		}
	}
	if(pPipe1!=NULL&&pPipe2!=NULL)
	{
		pPipe1->EndPt(pPipe2->EndPt());
		Del(pPipe2->GetKey());
	}
}
コード例 #8
0
void cAseLoader::ProcessMESH_TFACELIST( IN std::vector<D3DXVECTOR2>& vecVT, 
	OUT std::vector<ST_PNT_VERTEX>& vecVertex )
{
	int nLevel = 0;

	do 
	{
		char* szToken = GetToken();
		if(IsEqual(szToken, "{"))
		{
			++nLevel;
		}
		else if(IsEqual(szToken, "}"))
		{
			--nLevel;
		}
		else if(IsEqual(szToken, ID_MESH_TFACE))
		{
			int nFaceIndex = GetInteger();
			int nA = GetInteger();
			int nB = GetInteger();
			int nC = GetInteger();

			vecVertex[nFaceIndex * 3 + 0].t = vecVT[nA];
			vecVertex[nFaceIndex * 3 + 1].t = vecVT[nC];
			vecVertex[nFaceIndex * 3 + 2].t = vecVT[nB];
		}

	} while (nLevel > 0);
}
コード例 #9
0
void cAseLoader::ProcessMATERIAL_LIST()
{
	int nLevel = 0;

	do 
	{
		char* szToken = GetToken();
		if(IsEqual(szToken, "{"))
		{
			++nLevel;
		}
		else if(IsEqual(szToken, "}"))
		{
			--nLevel;
		}
		else if(IsEqual(szToken, ID_MATERIAL_COUNT))
		{
			m_vecMtlTex.resize(GetInteger());
		}
		else if(IsEqual(szToken, ID_MATERIAL))
		{
			int nMtlIndex = GetInteger();
			m_vecMtlTex[nMtlIndex] = new cMtlTex;
			ProcessMATERIAL(m_vecMtlTex[nMtlIndex]);
		}

	} while (nLevel > 0);
}
コード例 #10
0
void AseLoader::Process_POS_TRACK(OUT AseFrame* frame)
{
	std::vector<PositionSample>& posTrack = frame->GetPosTrack();
	int level = 0;
	do 
	{
		char* aseToken = GetToken();
		if (IsEqual(aseToken, "{"))
		{
			level++;
		}
		else if (IsEqual(aseToken, "}"))
		{
			level--;
		}
		else if (IsEqual(aseToken, ID_POS_SAMPLE))
		{
			//
			PositionSample ps;

			ps.frame = GetInteger();
			ps.pos.x = GetFloat();
			ps.pos.y = GetFloat();
			ps.pos.z = GetFloat();

			posTrack.push_back(ps);
		}
	} while (level > 0);

}
コード例 #11
0
ファイル: debug.cpp プロジェクト: mingpen/OpenNT
BOOL IsEqual(CERTIFICATENAMES& n1, CERTIFICATENAMES&n2)
	{
	if (n1.flags != n2.flags)
		return FALSE;
	if (n1.flags & CERTIFICATENAME_DIGEST)
		{
		if (memcmp(&n1.digest, &n2.digest, sizeof(n1.digest)) != 0)
			return FALSE;
		}
	if (n1.flags & CERTIFICATENAME_ISSUERSERIAL)
		{
		if (!IsEqual(n1.issuerSerial.issuerName, n2.issuerSerial.issuerName))
			return FALSE;
		if (!IsEqual(n1.issuerSerial.serialNumber, n2.issuerSerial.serialNumber))
			return FALSE;
		}
	if (n1.flags & CERTIFICATENAME_SUBJECT)
		{
		if (!IsEqual(n1.subject, n2.subject))
			return FALSE;
		}
	if (n1.flags & CERTIFICATENAME_ISSUER)
		{
		if (!IsEqual(n1.issuer, n2.issuer))
			return FALSE;
		}
	return TRUE;
	}
コード例 #12
0
double CTableLimits::GuessSmallBlindFromBigBlind()
{
	write_log(3, "CTableLimits::GuessSmallBlindFromBigBlind()\n");
	// Special case: 0.02/0.05/0.10
	if (IsEqual(tablelimit_unreliable_input.bblind, 0.05))
	{
		return 0.02;
	}
	// Special case: 0.05/0.15/0.30
	if (IsEqual(tablelimit_unreliable_input.bblind, 0.15))
	{
		return 0.05;
	}
	// Special case: 0.10/0.25/0.50
	if (IsEqual(tablelimit_unreliable_input.bblind, 0.25))
	{
		return 0.10;
	}
	// Special case: 0.02/0.05
	if (IsEqual(tablelimit_unreliable_input.bblind, 0.05))
	{
		return 0.02;
	}
	return (tablelimit_unreliable_input.bblind / 2);
}
コード例 #13
0
ファイル: list.c プロジェクト: LeoMirots/Lists
list search_and_destroy(element e, list l)
{
	list r = l;
	if (l == NULL)
		return NULL;
	if (detect(e, l) == false)
		return l;
	list tmp = l;
	if (IsEqual(head(l), e) == true)
	{
		l = DelFirst(l);
		return l;
	}
	while (llenght(l) != 1)
	{
		if (IsEqual(head(tail(l)), e) == true)
		{
			DeleteElement(l->next->value);
			tmp = l->next;
			l->next = l->next->next;
			free(tmp);
			return r;
		}
		l = tail(l);
	}
	return NULL;
}
コード例 #14
0
void Room::reorderWalls()
{
	int index;
	std::vector<MazeWall>::iterator it;
	MazeWall tempMaze;
	double tmpX =  walls[0].To_X;
	double tmpY = walls[0].To_Y;

	for(unsigned int i = 0; i < walls.size();i++)
	{
		index = getWallIndex(i + 1, tmpX ,tmpY);

		if(IsEqual(tmpX, walls[index].To_X) &&  IsEqual(tmpY,walls[index].To_Y))
		{
			tmpX =  walls[index].From_X;
			tmpY = walls[index].From_Y;
		}
		else
		{
			tmpX =  walls[index].To_X;
			tmpY = walls[index].To_Y;
		}

		it = walls.begin();

		if(index > -1)
		{
			tempMaze = walls[index];
			walls.erase(it + index);
			walls.insert(it + i + 1,tempMaze);
		}
	}
}
コード例 #15
0
int CGlobalVars::first_limper()
{
	/*
	*  
	*/

	//Check UTG...BT
	for(int i=3; i < k_MaxChairs; i++)
	{
		for(int j=0; j < k_MaxChairs; j++)
		{
			if(IsEqual(currentbets[j], get_bblind()) && (get_ac_dealpos(j) == i))
				return j;
		}
	}

	//Check SB
	for(int i=0; i < k_MaxChairs; i++)
	{
		if(IsEqual(currentbets[i], get_bblind()) && (get_ac_dealpos(i) == 1))
			return i;
	}

	return -1;
}
コード例 #16
0
void AseLoader::Process_ID_MESH_TFACELIST(IN std::vector<D3DXVECTOR2>& uv, OUT std::vector<FVF_PositionNormalTexture>& vertex)
{
	int level = 0;
	do 
	{
		char* aseToken = GetToken();
		if (IsEqual(aseToken, "{"))
		{
			level++;
		}
		else if (IsEqual(aseToken, "}"))
		{
			level--;
		}
		else if (IsEqual(aseToken, ID_MESH_TFACE))
		{		
			//
			int index = GetInteger();
			int a = GetInteger();
			int b = GetInteger();
			int c = GetInteger();

			vertex[index * 3 + 0].tex = uv[a];
			vertex[index * 3 + 1].tex = uv[c];
			vertex[index * 3 + 2].tex = uv[b];
		}
	} while (level > 0);
}
コード例 #17
0
cFrame* cAseLoader::Load( char* szFullPath )
{
	fopen_s(&m_fp, szFullPath, "r");
	while(char* szToken = GetToken())
	{
		if(IsEqual(szToken, ID_SCENE))
		{
			SkipBlock();
		}
		else if(IsEqual(szToken, ID_MATERIAL_LIST))
		{
			ProcessMATERIAL_LIST();
		}
		else if(IsEqual(szToken, ID_GEOMETRY))
		{
			cFrame* pFrame = ProcessGEOMOBJECT();
			m_mapFrame[pFrame->GetFrameName()] = pFrame;
			if(m_pRoot == NULL)
				m_pRoot = pFrame;
		}
	}
		
	fclose(m_fp);

	if(m_pRoot)
		m_pRoot->SetOriginLocalTM(NULL);

	return m_pRoot;
}
コード例 #18
0
void AseLoader::Process_TM_ANIMATION(OUT AseFrame* frame)
{
	int level = 0;
	do 
	{
		char* aseToken = GetToken();
		if (IsEqual(aseToken, "{"))
		{
			level++;
		}
		else if (IsEqual(aseToken, "}"))
		{
			level--;
		}
		else if (IsEqual(aseToken, ID_POS_TRACK))
		{
			Process_POS_TRACK(frame);
		}
		else if (IsEqual(aseToken, ID_ROT_TRACK))
		{
			Process_ROT_TRACK(frame);
		}
	} while (level > 0);

}
コード例 #19
0
void cAseLoader::ProcessMESH_VERTEX_LIST( OUT std::vector<D3DXVECTOR3>& vecV )
{
	int nLevel = 0;

	do 
	{
		char* szToken = GetToken();
		if(IsEqual(szToken, "{"))
		{
			++nLevel;
		}
		else if(IsEqual(szToken, "}"))
		{
			--nLevel;
		}
		else if(IsEqual(szToken, ID_MESH_VERTEX))
		{
			int nIndex = GetInteger();
			vecV[nIndex].x = GetFloat();
			vecV[nIndex].z = GetFloat();
			vecV[nIndex].y = GetFloat();
		}

	} while (nLevel > 0);
}
コード例 #20
0
ファイル: Mesh.cpp プロジェクト: aaalexandrov/Alex
bool CMesh::IntersectSegments(CVector<2> const &vA0, CVector<2> const &vA1, CVector<2> const &vB0, CVector<2> const &vB1, float &fTA, float &fTB)
{
  CVector<2> vA, vB, vBP, vAP, vD;
  float fD;

  vA = vA1 - vA0;
  vB = vB1 - vB0;
  vAP = vA.Perpendicular2D();
  vBP = vB.Perpendicular2D();

  fD = vA % vBP;
  if (IsEqual(fD, 0)) // Colinear or one of the vectors is 0, so we return no intersection
    return false;
  vD = vB0 - vA0;
  fTA = (vD % vBP) / fD;
  if (fTA < 0 || fTA > 1)
    return false;
  fTB = (vD % vAP) / fD;
  if (fTB < 0 || fTB > 1)
    return false;

  ASSERT(IsEqual(((vB0 + fTB * vB) - (vA0 + fTA * vA)).Length(), 0));

  return true;
}
コード例 #21
0
void AseLoader::Process_MESH_TVERTLIST(OUT std::vector<D3DXVECTOR2>& uv)
{
	int level = 0;
	do 
	{
		char* aseToken = GetToken();
		if (IsEqual(aseToken, "{"))
		{
			level++;
		}
		else if (IsEqual(aseToken, "}"))
		{
			level--;
		}
		else if (IsEqual(aseToken, ID_MESH_TVERT))
		{		
			//
			int index = GetInteger();
			float u = GetFloat();
			float v = GetFloat();

			uv[index] = D3DXVECTOR2(u, 1 - v);
		}
	} while (level > 0);
}
コード例 #22
0
void CSphere::Transform(CVector<3, Num> const &vCenter, Num nRadius, CXForm const &kXForm,
                        CVector<3, Num> &vXCenter, Num &nXRadius)
{
  CVector<3, Num> vScale;
  vScale = kXForm.GetScale();
  ASSERT(IsEqual(vScale.x(), vScale.y()) && IsEqual(vScale.y(), vScale.z()));
  vXCenter = kXForm.TransformPoint(vCenter);
  nXRadius = nRadius * vScale.x();
}
コード例 #23
0
	ERMsg COGRBaseOption::ProcessOption(int& i, int argc, char* argv[])
	{
		ERMsg msg;
		string error;


		if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "--utility_version"))
		{
			m_bVersion = true;
		}
		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-co") && i < argc - 1)
		{
			m_createOptions.push_back(argv[++i]);
		}
		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-of") && i < argc - 1)
		{
			m_format = argv[++i];
		}
		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-wo") && i < argc - 1)//working option
		{
			//UNIFIED_SRC_NODATA
			m_workOptions.push_back(argv[++i]);
		}
		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-multi"))
		{
			m_bMulti = true;
		}
		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-f") && i < argc - 1)
		{
			m_format = argv[i + 1];
		}
		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-overwrite"))
		{
			m_bOverwrite = true;
		}
		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-q"))
		{
			m_bQuiet = true;
		}
		else if (IsEqual(argv[i], "-?") || IsEqual(argv[i], "-help"))
		{
			m_bNeedHelp = true;
		}
		else if (argv[i][0] == '-')
		{
			error = string("ERROR: Invalid option: ") + argv[i] + ", use - ? for more help.\n";
			msg.ajoute(error);
			//return false;
		}
		else
		{
			m_filesPath.push_back(argv[i]);
		}

		return msg;
	}
コード例 #24
0
int Room::getWallIndex(int startIndex, double X,double Y)
{
	for(unsigned int i = startIndex; i < walls.size(); i++)
	{
		if((IsEqual(X, walls[i].From_X) && IsEqual(Y,walls[i].From_Y)) || (IsEqual(X, walls[i].To_X) && IsEqual(Y,walls[i].To_Y)))
			return i;
	}

	return -1;
}
コード例 #25
0
void PlayerHpBar::SetOffset(const std::string &target, Vector2f offset)
{
	if (IsEqual(target.c_str(), "avatar"))
	{
		m_avatarOffset = offset;
	}
	else if (IsEqual(target.c_str(), "bar"))
	{
		m_barOffset = offset;
	}
}
コード例 #26
0
int TranslateSeriesStatusFrom(const std::wstring& value) {
  if (IsEqual(value, L"Currently Airing")) {
    return anime::kAiring;
  } else if (IsEqual(value, L"Finished Airing")) {
    return anime::kFinishedAiring;
  } else if (IsEqual(value, L"Not Yet Aired")) {
    return anime::kNotYetAired;
  }

  LOG(LevelWarning, L"Unknown value: " + value);
  return anime::kUnknownStatus;
}
コード例 #27
0
ファイル: dlg_anime_info.cpp プロジェクト: Greathood/taiga
LRESULT AnimeDialog::OnNotify(int idCtrl, LPNMHDR pnmh) {
  switch (idCtrl) {
    case IDC_LINK_NOWPLAYING: {
      switch (pnmh->code) {
        // Link click
        case NM_CLICK: {
          PNMLINK pNMLink = reinterpret_cast<PNMLINK>(pnmh);
          wstring action = pNMLink->item.szUrl;
          if (IsEqual(pNMLink->item.szID, L"menu")) {
            action = UI.Menus.Show(m_hWindow, 0, 0, pNMLink->item.szUrl);
          } else if (IsEqual(pNMLink->item.szID, L"search")) {
            action = L"SearchAnime(" + CurrentEpisode.title + L")";
          } else if (IsEqual(pNMLink->item.szUrl, L"score")) {
            action = L"";
            CurrentEpisode.anime_id = ToInt(pNMLink->item.szID);
            auto anime_item = AnimeDatabase.FindItem(CurrentEpisode.anime_id);
            if (anime_item) {
              anime_item->AddtoUserList();
              auto synonyms = anime_item->GetUserSynonyms();
              synonyms.push_back(CurrentEpisode.title);
              anime_item->SetUserSynonyms(synonyms);
              Meow.UpdateCleanTitles(anime_item->GetId());
              Settings.Save();
              anime_item->StartWatching(CurrentEpisode);
              MainDialog.ChangeStatus();
            }
          }
          ExecuteAction(action, 0, GetCurrentId());
          return TRUE;
        }

        // Custom draw
        case NM_CUSTOMDRAW: {
          return CDRF_DODEFAULT;
        }
      }
      break;
    }

    case IDC_TAB_ANIME: {
      switch (pnmh->code) {
        // Tab select
        case TCN_SELCHANGE: {
          SetCurrentPage(tab_.GetCurrentlySelected() + 1);
          break;
        }
      }
      break;
    }
  }
  
  return 0;
}
コード例 #28
0
	ERMsg COGRBaseOption::ParseOption(int argc, char* argv[])
	{
		ERMsg msg;
		// Must process GDAL_SKIP before GDALAllRegister(), but we can't call 
		// GDALGeneralCmdLineProcessor before it needs the drivers to be registered 
		// for the --format or --formats options 
		for (int i = 1; i < argc; i++)
		{
			if (IsEqual(argv[i], "--config") && i + 2 < argc && IsEqual(argv[i + 1], "GDAL_SKIP"))
			{
				CPLSetConfigOption(argv[i + 1], argv[i + 2]);

				i += 2;
			}
		}

		// -------------------------------------------------------------------- 
		//      Register standard GDAL drivers, and process generic GDAL        
		//      command options.                                                
		// -------------------------------------------------------------------- 
		OGRRegisterAll();
		argc = OGRGeneralCmdLineProcessor(argc, &argv, 0);
		if (argc < 1)
			exit(-argc);

		// -------------------------------------------------------------------- 
		//      Parse arguments.                                                
		// -------------------------------------------------------------------- 
		for (int i = 1; i < argc; i++)
		{
			msg += ProcessOption(i, argc, argv);
		}

		if (m_bVersion)
		{
			string error = Format("%s was compiled against GDAL %s and is running against GDAL %s\n",
				argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));

			msg.ajoute(error);
			//return msg;
		}

		if (m_bNeedHelp)
		{
			msg.ajoute(GetUsage());
			msg.ajoute(GetHelp());
			//return msg;
		}


		return msg;
	}
コード例 #29
0
/**
 * Virtual function to calculate a point for this fucntion.
 * @param x (input) x input value for this function.
 * @return Y value corresponding to the x input.
 */
TMathResult
TrigFunction::CalculateY(
	double x,
	double *y)
{
	TMathResult status = MATH_SUCCESS;
	double result = 0;
	double angle = x;
	if(GetAngleMode() == MATH_ANGLES_IN_DEGREES)
	{
		angle = DegreesToRadians(x);
	}

	switch(GetOperatorType())
	{
	case MATH_SIN:
		result = sin(angle);
		break;
	case MATH_COS:
		result = cos(angle);
		break;
	case MATH_TAN:
		result = tan(angle);
		break;
	case MATH_COT:
		result = tan(angle);
		if(!IsEqual(result, 0))
			result = 1/result;
		else
			status = MATH_UNDEFINED;
		break;
	case MATH_SEC:
		result = cos(angle);
		if(!IsEqual(result, 0))
			result = 1/result;
		else
			status = MATH_UNDEFINED;
		break;
	case MATH_CSC:
		result = sin(angle);
		if(!IsEqual(result, 0))
			result = 1/result;
		else
			status = MATH_UNDEFINED;
		break;
	}

	if(status == MATH_SUCCESS)
		*y = result;

	return status;
}
コード例 #30
0
ファイル: ButtonComponent.cpp プロジェクト: PaulPopa/Games
uint ButtonComponent::GetStyleIndex(const std::string& style)
{
	if (IsEqual(style.c_str(), "deep_on_click"))
	{
		return DEEP_ON_CLICK;
	}
	else if (IsEqual(style.c_str(), "deep_on_focus"))
	{
		return DEEP_ON_FOCUS;
	}
	assert(nullptr);
	return 100;
}