TPolyLine3D* BasicHorizontalRectangularDetectorElement::GeneratePolyLine3D()
{
	TPolyLine3D* pPolyLine = new TPolyLine3D(5);
//	printf("---------MinX: %f, Maxx:%f, Miny: %f, MaxY:%f, Z: %f\n", GetMinX(), GetMaxX(), GetMinY(), GetMaxY(), GetZOffset());
	pPolyLine->SetPoint(0, GetMinX(), GetMinY(), GetZOffset());
	pPolyLine->SetPoint(1, GetMaxX(), GetMinY(), GetZOffset());
	pPolyLine->SetPoint(2, GetMaxX(), GetMaxY(), GetZOffset());
	pPolyLine->SetPoint(3, GetMinX(), GetMaxY(), GetZOffset());
	pPolyLine->SetPoint(4, GetMinX(), GetMinY(), GetZOffset());
	return pPolyLine;
}
Beispiel #2
0
void Camera::SetX(double x) {
	if ( !HasBounds() ) {
		this->x = x;
	} else {
		if ( x < GetMinX() )
			this->x = GetMinX();
		else if ( x > GetMaxX() )
			this->x = GetMaxX();
		else
			this->x = x;
	}
}
Beispiel #3
0
void FunctionSimple::SetMaxX(float f)
{
  // Offset is avg of min and max.
  m_offsetX = (f + GetMinX()) / 2.0f;
  // Multiplier is max - offset, or offset - min
  m_multiplierX = fabs(f - m_offsetX);
}
bool FGAFRect::IntersectsRect(const FGAFRect& rect) const
{
    return !(     GetMaxX() < rect.GetMinX() ||
             rect.GetMaxX() <      GetMinX() ||
                  GetMaxY() < rect.GetMinY() ||
             rect.GetMaxY() <      GetMinY());
}
Beispiel #5
0
double XYDataset::GetMinValue(bool verticalAxis)
{
	if (verticalAxis) {
		return GetMinY();
	}
	else {
		return GetMinX();
	}
}
bool FGAFRect::ContainsPoint(const FVector2D& point) const
{
    bool bRet = false;

    if (point.X >= GetMinX() && point.X <= GetMaxX()
        && point.Y >= GetMinY() && point.Y <= GetMaxY())
    {
        bRet = true;
    }

    return bRet;
}
void FGAFRect::Merge(const FGAFRect& rect)
{
    float top1 = GetMaxY();
    float left1 = GetMinX();
    float right1 = GetMaxX();
    float bottom1 = GetMinY();
    
    float top2 = rect.GetMaxY();
    float left2 = rect.GetMinX();
    float right2 = rect.GetMaxX();
    float bottom2 = rect.GetMinY();
    Origin.X = FMath::Min(left1, left2);
    Origin.Y = FMath::Min(bottom1, bottom2);
    Size.Width = FMath::Max(right1, right2) - Origin.X;
    Size.Height = FMath::Max(top1, top2) - Origin.Y;
}
Beispiel #8
0
    bool BattleRideFighter::PreGetObject()
    { 
        //获取战斗对象
        PreGetObject1() ;
        if(!_target)
            return false;
        if(count > 3)
            return false;
        if(!count || (getPosX() == _battleTargetX && getPosY() == _battleTargetY ))// || getPosX() >= (FIELD_WIDTH - 100) )
        {
            switch(count)
            {
                case 0:  //第一次出发
                    {
                        _battleTargetX = (getPosX() > (FIELD_WIDTH)/2) ? 100:(FIELD_WIDTH-100);
                        break;
                    }
                case 1:  //回头
                    {
                        _battleTargetX = GetMinX();
                        _battleTargetY = GetMinY();
                        break;
                    }
                case 2:  //停
                    {
                        SetBattleTargetPos(getPosX(),getPosY());
                        break;
                    }
                default:
                    return false ;
            }
            count++;
            //COUT << "战将编号:" << static_cast<UInt32>(GetBSNumber()) << "目的地:" << static_cast<UInt32>(_battleTargetX) << " , " << static_cast<UInt32>(_battleTargetY) << std::endl;
        }


        if(!_battleTargetY)
        {
            _battleTargetY = _target->getPosY();
        }
        BuildLocalStream(e_run);
        return true;
    } 
void CUmbralActor::RebuildActorRenderables()
{
	uint32 modelFolder = m_baseModelId % 10000;
	uint32 modelClass = m_baseModelId / 10000;
	const char* charaFolder = "";
	const char* charaPrefix = "";
	switch(modelClass)
	{
	case 1:
		charaFolder = "mon";
		charaPrefix = "m";
		break;
	case 2:
		charaFolder = "bgobj";
		charaPrefix = "b";
		break;
	case 4:
		charaFolder = "wep";
		charaPrefix = "w";
		break;
	default:
		assert(0);
		break;
	}

	uint32 subModelId = m_topModelId >> 10;
	uint32 variation = m_topModelId & 0x3FF;

	auto gamePath = CFileManager::GetGamePath();
	auto modelPath = string_format("%s/client/chara/%s/%s%0.3d/equ/e%0.3d/top_mdl/0001",
		gamePath.string().c_str(), charaFolder, charaPrefix, modelFolder, subModelId);

	Framework::CStdStream inputStream(modelPath.c_str(), "rb");

	auto modelResource = CSectionLoader::ReadSection(ResourceNodePtr(), inputStream);

	auto modelChunk = modelResource->SelectNode<CModelChunk>();
	assert(modelChunk);
	if(!modelChunk) return;

	auto boundingBox = modelChunk->SelectNode<CCompChunk>();

	CVector3 boxMin(boundingBox->GetMinX(), boundingBox->GetMinY(), boundingBox->GetMinZ());
	CVector3 boxMax(boundingBox->GetMaxX(), boundingBox->GetMaxY(), boundingBox->GetMaxZ());

	CVector3 modelSize = (boxMax - boxMin) / 2;
	CVector3 modelPos = (boxMax + boxMin) / 2;

	auto model = std::make_shared<CUmbralModel>(modelChunk);
	model->SetPosition(modelPos);
	model->SetScale(modelSize);
	AppendChild(model);

	auto modelBoundingSphere = model->GetBoundingSphere();
	modelBoundingSphere.radius *= std::max(std::max(modelSize.x, modelSize.y), modelSize.z);
	modelBoundingSphere.position += modelPos;
	m_boundingSphere = modelBoundingSphere;

	uint32 textureId = 0;
	if(modelClass == 4)
	{
		uint32 varWepId = 1000000000 + (modelFolder * 1000000) + (subModelId * 1000) + variation;
		auto var = CWeaponVars::GetInstance().GetVarForId(varWepId);
		textureId = var.textureId;

		for(const auto& meshNode : model->GetChildren())
		{
			if(auto mesh = std::dynamic_pointer_cast<CUmbralMesh>(meshNode))
			{
				auto meshName = mesh->GetName();
				int materialId = 0;
				if(meshName.find("_a") != std::string::npos)
				{
					materialId = 0;
				}
				if(meshName.find("_b") != std::string::npos)
				{
					materialId = 1;
				}
				if(meshName.find("_c") != std::string::npos)
				{
					materialId = 2;
				}
				if(meshName.find("_d") != std::string::npos)
				{
					assert(0);
				}
				const auto& varWepMaterial = var.materials[materialId];
				auto material = mesh->GetMaterial();
				ReplaceMaterialParam(material, "ps_diffuseColor", varWepMaterial.diffuseColor);
				ReplaceMaterialParam(material, "ps_multiDiffuseColor", varWepMaterial.multiDiffuseColor);
				ReplaceMaterialParam(material, "ps_specularColor", varWepMaterial.specularColor);
				ReplaceMaterialParam(material, "ps_multiSpecularColor", varWepMaterial.multiSpecularColor);
				ReplaceMaterialParam(material, "ps_reflectivity", varWepMaterial.specularColor);
				ReplaceMaterialParam(material, "ps_multiReflectivity", varWepMaterial.multiSpecularColor);
				ReplaceMaterialParam(material, "ps_shininess", varWepMaterial.shininess);
				ReplaceMaterialParam(material, "ps_multiShininess", varWepMaterial.multiShininess);
				mesh->SetActivePolyGroups(var.polyGroupState);
			}
		}
	}

	{
		auto texturePath = string_format("%s/client/chara/%s/%s%0.3d/equ/e%0.3d/top_tex2/%0.4d",
			gamePath.string().c_str(), charaFolder, charaPrefix, modelFolder, subModelId, textureId);

		Framework::CStdStream inputStream(texturePath.c_str(), "rb");
		auto textureResource = CSectionLoader::ReadSection(ResourceNodePtr(), inputStream);
		model->SetLocalTexture(textureResource);
	}

	m_renderableDirty = false;
}
Beispiel #10
0
 fixed GetYAtMinX() const {
   return GetYAt(GetMinX());
 }