C++ float3::SqDistance方法代码示例

std::vector<CFeature*> CQuadField::GetFeaturesExact(const float3& pos, float radius)
{
    GML_RECMUTEX_LOCK(qnum); // GetFeaturesExact

    const std::vector<int>& quads = GetQuads(pos, radius);
    const int tempNum = gs->tempNum++;

    std::vector<CFeature*> features;
    std::vector<int>::const_iterator qi;
    std::list<CFeature*>::iterator fi;

    for (qi = quads.begin(); qi != quads.end(); ++qi) {
        for (fi = baseQuads[*qi].features.begin(); fi != baseQuads[*qi].features.end(); ++fi) {
            if ((*fi)->tempNum == tempNum) {
                continue;
            }
            if (pos.SqDistance((*fi)->midPos) >= Square(radius + (*fi)->radius)) {
                continue;
            }

            (*fi)->tempNum = tempNum;
            features.push_back(*fi);
        }
    }

    return features;
}

// should only be used by air
bool CTransportCAI::FindEmptyDropSpots(float3 startpos, float3 endpos, std::list<float3>& dropSpots)
{
	const float gap = 25.5f; // TODO - set tag for this?
	const float3 dir = (endpos - startpos).Normalize();

	float3 nextPos = startpos;

	dropSpots.push_front(nextPos);

	if (dynamic_cast<CHoverAirMoveType*>(owner->moveType) == NULL)
		return false;

	const auto& transportees = static_cast<CTransportUnit*>(owner)->GetTransportedUnits();
	auto ti = transportees.begin();

	// first spot
	if (ti != transportees.end()) {
		nextPos += (dir * (gap + ti->unit->radius));
		++ti;
	}

	// remaining spots
	while (ti != transportees.end() && startpos.SqDistance(nextPos) < startpos.SqDistance(endpos)) {
		nextPos += (dir * (ti->unit->radius));
		nextPos.y = CGround::GetHeightAboveWater(nextPos.x, nextPos.z);

		// check landing spot is ok for landing on
		if (!SpotIsClear(nextPos, ti->unit))
			continue;

		dropSpots.push_front(nextPos);
		nextPos += (dir * (gap + ti->unit->radius));
		++ti;
	}

	return true;
}

bool CTransportCAI::FindEmptyDropSpots(float3 startpos, float3 endpos, std::list<float3>& dropSpots)
{
	//should only be used by air

	CTransportUnit* transport = static_cast<CTransportUnit*>(owner);
	//dropSpots.clear();
	float gap = 25.5; // TODO - set tag for this?
	float3 dir = endpos - startpos;
	dir.Normalize();

	float3 nextPos = startpos;
	float3 pos;

	std::list<CTransportUnit::TransportedUnit>::const_iterator ti = transport->GetTransportedUnits().begin();
	dropSpots.push_front(nextPos);

	// first spot
	if (ti != transport->GetTransportedUnits().end()) {
		nextPos += dir * (gap + ti->unit->radius);
		++ti;
	}

	// remaining spots
	if (dynamic_cast<CHoverAirMoveType*>(owner->moveType)) {
		while (ti != transport->GetTransportedUnits().end() && startpos.SqDistance(nextPos) < startpos.SqDistance(endpos)) {
			nextPos += dir * (ti->unit->radius);
			nextPos.y = ground->GetHeightAboveWater(nextPos.x, nextPos.z);

			// check landing spot is ok for landing on
			if (!SpotIsClear(nextPos,ti->unit))
				continue;

			dropSpots.push_front(nextPos);
			nextPos += dir * (gap + ti->unit->radius);
			++ti;
		}
		return true;
	}
	return false;
}

static inline bool equals_distance(const float3& f1, const float3& f2)
{
	return ((f1.x == f2.x) && (f1.y == f2.y) && (f1.z == f2.z))
		|| epscmp2(f1.SqDistance(f2));
}

// optimization specifically for projectile collisions
void CQuadField::GetUnitsAndFeaturesColVol(
    const float3& pos,
    const float radius,
    std::vector<CUnit*>& units,
    std::vector<CFeature*>& features,
    unsigned int* numUnitsPtr,
    unsigned int* numFeaturesPtr
) {
    GML_RECMUTEX_LOCK(qnum); // GetUnitsAndFeaturesColVol

    const int tempNum = gs->tempNum++;

    // start counting from the previous object-cache sizes
    unsigned int numUnits = (numUnitsPtr == NULL)? 0: (*numUnitsPtr);
    unsigned int numFeatures = (numFeaturesPtr == NULL)? 0: (*numFeaturesPtr);

    int* begQuad = &tempQuads[0];
    int* endQuad = &tempQuads[0];

    // bail early if caches are already full
    if (numUnits >= units.size())
        return;
    if (numFeatures >= features.size())
        return;

    assert(numUnits == 0 || units[numUnits] == NULL);
    assert(numFeatures == 0 || features[numFeatures] == NULL);

    GetQuads(pos, radius, begQuad, endQuad);

    std::list<CUnit*>::const_iterator ui;
    std::list<CFeature*>::const_iterator fi;

    for (int* a = begQuad; a != endQuad; ++a) {
        const Quad& quad = baseQuads[*a];

        for (ui = quad.units.begin(); ui != quad.units.end(); ++ui) {
            CUnit* u = *ui;

            // prevent double adding
            if (u->tempNum == tempNum)
                continue;

            const auto* colvol = u->collisionVolume;
            const float totRad = radius + colvol->GetBoundingRadius();

            if (pos.SqDistance(colvol->GetWorldSpacePos(u)) >= (totRad * totRad))
                continue;

            assert(numUnits < units.size());

            if (numUnits < units.size()) {
                u->tempNum = tempNum;
                units[numUnits++] = u;
            }
        }

        for (fi = quad.features.begin(); fi != quad.features.end(); ++fi) {
            CFeature* f = *fi;

            // prevent double adding
            if (f->tempNum == tempNum)
                continue;

            const auto* colvol = f->collisionVolume;
            const float totRad = radius + colvol->GetBoundingRadius();

            if (pos.SqDistance(colvol->GetWorldSpacePos(f)) >= (totRad * totRad))
                continue;

            assert(numFeatures < features.size());

            if (numFeatures < features.size()) {
                f->tempNum = tempNum;
                features[numFeatures++] = f;
            }
        }
    }

    assert(numUnits < units.size());
    assert(numFeatures < features.size());

    // set end-of-list sentinels
    if (numUnits < units.size())
        units[numUnits] = NULL;
    if (numFeatures < features.size())
        features[numFeatures] = NULL;

    if (numUnitsPtr != NULL) {
        *numUnitsPtr = numUnits;
    }
    if (numFeaturesPtr != NULL) {
        *numFeaturesPtr = numFeatures;
    }
}