C++ VC3函数代码示例

//------------------------------------------------------------------
// Storm3D_Camera::TestPointVisibility
//------------------------------------------------------------------
bool Storm3D_Camera::TestPointVisibility(const VC3 &pointpos)
{
	if(forcedOrthogonalProjection) // Todo: real check
		return true;

	// Update vis planes, if needed
	if (visplane_update_needed) UpdateVisPlanes();

	// Back/Front planes
	float er=VC3(pointpos.x-position.x,
		pointpos.y-position.y,pointpos.z-position.z).GetDotWith(pnormals[0]);
	if (er<0) return false;
	if (er>vis_range) return false;
	
	// Side Planes
	if (VC3(pointpos.x-position.x,pointpos.y-position.y,
		pointpos.z-position.z).GetDotWith(pnormals[1])
		<0) return false;

	if (VC3(pointpos.x-position.x,pointpos.y-position.y,
		pointpos.z-position.z).GetDotWith(pnormals[2])
		<0) return false;

	// Up/Down planes
	if (VC3(pointpos.x-position.x,pointpos.y-position.y,
		pointpos.z-position.z).GetDotWith(pnormals[3])
		<0) return false;

	if (VC3(pointpos.x-position.x,pointpos.y-position.y,
		pointpos.z-position.z).GetDotWith(pnormals[4])
		<0) return false;

	// It's visible (at last)
	return true;
}

	CameraAutotilter::CameraAutotilter(game::GameMap *gameMap)
	{
		this->gameMap = gameMap;
		this->lastRotation = VC3(0,0,0);
		this->lastPosition = VC3(0,0,0);
		this->lastTime = Timer::getTime();
	}

ScriptableAIDirectControl::ScriptableAIDirectControl(Game *game, Unit *unit)
{
    this->game = game;
    this->unit = unit;

    this->eventMask = 0;

    this->previousEventsOnMask = 0;
    //this->actions = AIDirectControlActions(); // does not need init
    //this->actionsToDisableAutomatically = AIDirectControlActions(); // does not need init

    this->aimMode = AIM_MODE_OFFSET_SELF;
    this->aimPosition = VC3(0,0,0);
    this->aimPositionResult = VC3(0,0,0);

    this->timerTicksAmount = 1;
    this->lastTimerCall = 0;

    this->customEventsUsed = 0;
    for (int i = 0; i < SCRIPTABLEAIDIRECTCONTROL_MAX_CUSTOM_EVENTS; i++)
    {
        this->customEventsTicksLeft[i] = 0;
        this->customEventsName[i] = NULL;
    }
}

	void OptionApplier::applyCameraOptions(IStorm3D_Scene *scene)
	{
		if (SimpleOptions::getBool(DH_OPT_B_GAME_SIDEWAYS))
		{
			scene->GetCamera()->SetUpVec(VC3(0,0,1));
		} else {
			scene->GetCamera()->SetUpVec(VC3(0,1,0));
		}
	}

VectorDamper::VectorDamper()
{
	pos = VC3(0, 0, 0);
	speed = VC3(0, 0, 0);
	target = VC3(0, 0, 0);
	mass = 1.0f;
	k = 0.1f;
	overdampFactor = 1.0f;
	calculateC();
}

	void DebugTrackerVisualizer::visualizeTrackers(game::tracking::ObjectTracker *objectTracker)
	{
		assert(objectTracker != NULL);

		std::vector<ITrackerObject *> trackerList = objectTracker->getAllTrackers();

		for (int i = 0; i < (int)trackerList.size(); i++)
		{
			ITrackerObject *tracker = trackerList[i];

			std::string trackerName = tracker->getType()->getTrackerTypeName();
			
			COL col = COL(0,0,1);

			VC3 pos = tracker->getTrackerPosition();
			VC3 sizes = VC3(0.1f, 0.1f, 0.1f);

			if (trackerName == "projectile")
			{
				col = COL(1.0f,0.7f,0.0f);
				sizes *= 1.5f;
			}

			VC3 c1 = VC3(pos.x - sizes.x, pos.y + sizes.y, pos.z - sizes.z);
			VC3 c2 = VC3(pos.x + sizes.x, pos.y + sizes.y, pos.z - sizes.z);
			VC3 c3 = VC3(pos.x + sizes.x, pos.y + sizes.y, pos.z + sizes.z);
			VC3 c4 = VC3(pos.x - sizes.x, pos.y + sizes.y, pos.z + sizes.z);
			VC3 cb1 = VC3(pos.x - sizes.x, pos.y - sizes.y, pos.z - sizes.z);
			VC3 cb2 = VC3(pos.x + sizes.x, pos.y - sizes.y, pos.z - sizes.z);
			VC3 cb3 = VC3(pos.x + sizes.x, pos.y - sizes.y, pos.z + sizes.z);
			VC3 cb4 = VC3(pos.x - sizes.x, pos.y - sizes.y, pos.z + sizes.z);

			float extra_offset = 0.0f + (i / 200.0f);
			VC3 cb4_extra = VC3(pos.x - sizes.x - extra_offset, pos.y - sizes.y, pos.z + sizes.z);

			disposable_scene->AddLine(c1, c2, col);
			disposable_scene->AddLine(c2, c3, col);
			disposable_scene->AddLine(c3, c4, col);
			disposable_scene->AddLine(c4, c1, col);
			disposable_scene->AddLine(cb1, cb2, col);
			disposable_scene->AddLine(cb2, cb3, col);
			disposable_scene->AddLine(cb3, cb4, col);
			disposable_scene->AddLine(cb4, cb1, col);
			disposable_scene->AddLine(c1, cb1, col);
			disposable_scene->AddLine(c2, cb2, col);
			disposable_scene->AddLine(c3, cb3, col);
			disposable_scene->AddLine(c4, cb4, col);
			disposable_scene->AddLine(c4, cb4, col);

			COL col2 = COL(0,1,1);
			disposable_scene->AddLine(c4, cb4_extra, col2);

		}
	}

// Sets the position of interest and elapsed time for the camera system. Must be used before querying
// camera parameters.
void CameraSystemAim::update( VC3 positionOfInterest, int elapsedTime )
{

	cameraPosition = positionOfInterest + VC3(0, 1.395f, 0);
	targetPosition = aimPosition;
	targetPosition.y = cameraPosition.y + sinf(betaAngle);
	cameraPosition = cameraPosition + (cameraPosition-targetPosition).GetNormalized()*1.687f;
	upVector = VC3(0, 1, 0);
	QUAT tmp_quat3( (targetPosition-cameraPosition).GetNormalized(), DEG2RAD( -7.7f ));
	tmp_quat3.RotateVector( upVector );
	FOV = 70.0f;
}

bool Storm3D_Camera::TestBoxVisibility(const VC3 &min, const VC3 &max)
{

	if(forcedOrthogonalProjection) // Todo: real check
		return true;

	VC3 size = max - min;
	VC3 vertices[8] = 
	{
		VC3(min.x, min.y, min.z),
		VC3(min.x + size.x, min.y, min.z),
		VC3(min.x + size.x, min.y + size.y, min.z),
		VC3(min.x + size.x, min.y + size.y, min.z + size.z),
		VC3(min.x + size.x, min.y, min.z + size.z),
		VC3(min.x, min.y + min.y, min.z),
		VC3(min.x, min.y + min.y, min.z + min.z),
		VC3(min.x, min.y, min.z + min.z),
	};

	float origoDistance = position.GetRangeTo(VC3());

	bool allInside = true;
	for(int i = 0; i < 5; ++i)
	{
        bool allOutside = true;

		if(i == 0)
		{
			for(int j = 0; j < 8; ++j)
			{
				float distance = pnormals[i].GetDotWith(vertices[j]) + origoDistance + vis_range;

				allOutside = allOutside && (distance >= 0);
				allInside = allInside && (distance < 0);

				if(!allOutside && !allInside)
					break;
			}
		}

		for(int j = 0; j < 8; ++j)
		{
			float distance = pnormals[i].GetDotWith(vertices[j]) + origoDistance;

			allOutside = allOutside && (distance < 0);
			allInside = allInside && (distance >= 0);

			if(!allOutside && !allInside)
				break;
		}

        if(allOutside)
            return false;
	}

	return true;
}

	void AbstractPhysicsObject::syncInactiveImplementationObject(PHYSICS_ACTOR &obj)
	{
		if(!dynamicActor)
			return;

		if (moveToVelocity)
		{
			obj->setVelocity(velocity);
			moveToVelocity = false;
		}

		if (moveToAngularVelocity)
		{
			obj->setAngularVelocity(angularVelocity);
			moveToAngularVelocity = false;
		}

		if (doImpulse)
		{
			obj->addImpulse(impulsePosition, impulse);
			impulsePosition = VC3(0,0,0);
			impulse = VC3(0,0,0);
			doImpulse = false;
		}

		if (moveToPosition)
		{
			if (attemptedPosition)
			{
				obj->movePosition(position);
				attemptedPosition = false;
			} else {
				obj->setPosition(position);
			}
			moveToPosition = false;
		}

		if (moveToRotation)
		{
			if (attemptedRotation)
			{
				obj->moveRotation(rotation);
				attemptedRotation = false;
			} else {
				obj->setRotation(rotation);
			}
			moveToRotation = false;
		}

		this->dirty = false;
	}

void WorldFold::resetWorldFold()
{
	for (int i = 0; i < MAX_WORLD_FOLDS; i++)
	{
		worldFoldMatrix[i].CreateIdentityMatrix();
		worldFoldResultMatrix[i].CreateIdentityMatrix();
		worldFoldExists[i] = false;
		worldFoldKey[i] = 1;
	}
	worldFoldCenter = VC3(0,0,0);

	wfCameraMatrix.CreateIdentityMatrix();
	wfCameraPosition = VC3(0,0,0);
}

Rect getScreenArea(const AABB &aabb, Game  *game)
{
	VC3 v[8];
	v[0] = VC3(aabb.mmin.x, aabb.mmin.y, aabb.mmin.z);
	v[1] = VC3(aabb.mmax.x, aabb.mmin.y, aabb.mmin.z);
	v[2] = VC3(aabb.mmin.x, aabb.mmax.y, aabb.mmin.z);
	v[3] = VC3(aabb.mmin.x, aabb.mmin.y, aabb.mmax.z);
	v[4] = VC3(aabb.mmax.x, aabb.mmax.y, aabb.mmin.z);
	v[5] = VC3(aabb.mmin.x, aabb.mmax.y, aabb.mmax.z);
	v[6] = VC3(aabb.mmax.x, aabb.mmin.y, aabb.mmax.z);
	v[7] = VC3(aabb.mmax.x, aabb.mmax.y, aabb.mmax.z);

	Point start = convertVC3toScreen(v[0], game);
	Point end = start;

	for(int i = 1; i < 8; ++i)
	{
		Point p = convertVC3toScreen(v[i], game);
		start.x = std::min(start.x, p.x);
		start.y = std::min(start.y, p.y);
		end.x = std::max(end.x, p.x);
		end.y = std::max(end.y, p.y);
	}

	Rect rect;
	rect.x = start.x;
	rect.y = start.y;
	rect.w = end.x - start.x;
	rect.h = end.y - start.y;

	return rect;
}

	ProgressBar::ProgressBar()
	{
		interruptPercent = 1.0f;

		timeDone = 0;
		timeTotal = 1;
		timeTick = 0;

		unit = NULL;

		label = NULL;
		doneLabel = NULL;
		interruptedLabel = NULL;

		borderImage = NULL;
		barImage = NULL;

		visible = false;
		visibilityLeftCounter = 0;

		doneTriggered = false;
		nextTickTrigger = 0;

		progressing = false;
		triggerInterrupted = false;

		progressPosition = VC3(0,0,0);
		progressAngle = 0;

		restartedWhileVisible = false;
	}

bool ClawUnitActor::setPathTo(Unit *unit, const VC3 &destination_)
{
	VC3 destination = destination_;
	frozenbyte::ai::Path *path = solvePath(unit, unit->getPosition(), destination);
	
	// luckily, getPath may modify the destination value, if it is blocked
	// so no need to check that here.

	if (path != NULL)
	{
		unit->setPath(path);
		unit->setPathIndex(unit->getPathIndex() + 1);
		// (...path object is now contained within the unit, 
		// unit will handle it's proper deletion)
		unit->setWaypoint(unit->getPosition());
		unit->setFinalDestination(VC3(destination.x, 
			game->gameMap->getScaledHeightAt(destination.x, destination.z), 
			destination.z));
		return true;
	} else {		
		unit->setPath(NULL);
		unit->setFinalDestination(unit->getPosition());
		unit->setWaypoint(unit->getPosition());
		return false;
	} 
}

	Storm3D_SpotlightData(Storm3D &storm_, IDirect3D9 &d3d, IDirect3DDevice9 &device_, bool ps14_, bool ps20_)
	:	storm(storm_),
		device(device_),
		properties(device),
		coneColorMultiplier(0.3f),
		//smoothness(5.f),
		smoothness(5.f),
		ps14(ps14_),
		ps20(ps20_),
		smoothing(false),
		spotlightAlwaysVisible(false),
		camera(&storm),
		hasFade(false),
		hasCone(false),
		scissorRect(true),
		hasShadows(false),
		enabled(true),
		visible(false),
		coneUpdated(false),

		updateCone(true),
		noShadowModel(0),
		light_type(IStorm3D_Spotlight::Directional),
		coneFov(0)
	{
		properties.direction = VC3(0, 0, 1.f);
		properties.color = COL(1.f, 1.f, 1.f);
		shadowMap = staticBuffers.getShadowMap();

		angle[0] = angle[1] = 0.f;
		speed[0] = 0.07f;
		speed[1] = -0.11f;
	}

	void DebugVisualizerTextUtil::renderText(const VC3 &position, int offsetX, int offsetY, const char *text)
	{
		if (ui::defaultIngameFont != NULL)
		{
			IStorm3D_Font *f = ((OguiStormFont *)ui::defaultIngameFont)->fnt;

			if (text == NULL)
				text = "(null)";

			VC3 pos = position;
			VC3 result = VC3(0,0,0);
			float rhw = 0;
			float real_z = 0;
			IStorm3D_Camera *cam = disposable_scene->GetCamera();
			bool infront = cam->GetTransformedToScreen(pos, result, rhw, real_z);

			if (infront)
			{
				bool offscreen = false;
				int x = (int)(result.x * scr_width);
				int y = (int)(result.y * scr_height);
				if (x < 0 || y < 0 || x >= scr_width || y >= scr_height)
					offscreen = true;

				if (!offscreen)
				{
					float scrfloatx = (float)(x + offsetX);
					float scrfloaty = (float)(y + offsetY);
					float alpha = 1.0f;
					COL col = COL(1,1,1);
					disposable_scene->Render2D_Text(f, VC2(scrfloatx, scrfloaty), VC2(16, 16), text, alpha, col);
				}
			}
		}
	}