Camera - Revision history

Winkio at 18:35, 21 June 2024

2024-06-21T18:35:22Z

← Older revision		Revision as of 14:35, 21 June 2024
Line 1:		Line 1:
	A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place or move dynamically, and many games have sophisticated camera systems that include collision and physics.		A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place or move dynamically, and many games have sophisticated camera systems that include collision and physics.

	==~~Follow~~==		==Transition==
	~~One of the most~~ common ~~behaviors implemented on dynamic cameras~~ is ~~the ability to follow~~ a ~~target~~, ~~often~~ the ~~player~~.		Often a static camera will need to move from one location to another, which is called a transition. A common use for a camera transition is when a character moves between two adjacent rooms, and the camera transitions from only showing room A to only showing room B.

	===~~Rigid Follow~~===		===Linear Interpolation===
	The simplest implementation ~~to achieve follow behavior~~ is to ~~rigidly lock your camera~~ to ~~the follow target. This was often done with early 2D games, where~~ the camera ~~would keep~~ the ~~player in the center of the screen at all times, unless the camera hit the scroll boundary of~~ the ~~map~~.		The simplest implementation for a transition is to use linear interpolation to move the camera from the starting point to the ending point over a transition time.

	<syntaxhighlight lang="cs">		<syntaxhighlight lang="cs">
	Vector3 CameraPosition;		Vector3 CameraPosition;
	Vector3 ~~FollowTarget~~;		// camera position at transition start
	Vector3 ~~FollowOffset~~ = ~~Vector3.Zero~~;		Vector3 TransitionStart;
			// camera position at transition end
			Vector3 TransitionEnd;
			// progress through current transition
			float TransitionProgressTime;
			// Total transition time in seconds
			float TransitionTime;

			void BeginTransition(Vector3 transitionEnd, float transitionTime)
			{
			TransitionStart = CameraPosition;
			TransitionEnd = transitionEnd;
			TransitionTime = transitionTime;
			TransitionProgressTime = 0f;
			}

	void Update(float dt)		void Update(float dt)
	{		{
	CameraPosition = ~~FollowTarget~~ + ~~FollowOffset~~;		// if a transition is in progress
			if (TransitionProgressTime < TotalTransitionTime)
			{
			TransitionProgressTime += dt;
			if (TransitionProgressTime < TotalTransitionTime)
			{
			var t = TransitionProgressTime / TotalTransitionTime;
			// linear interpolation
			CameraPosition = TransitionStart + t * (TransitionEnd - TransitionStart);
			}
			else
			{
			CameraPosition = TransitionEnd;
			}
			}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

	==~~=Interpolation=~~==		==Follow==
	~~Sometimes~~ the ~~desired behavior~~ is ~~for~~ the ~~camera~~ to ~~trail behind the~~ follow target. The simplest implementation ~~for this~~ behavior is to ~~use interpolation~~ to ~~move~~ the camera ~~a percentage~~ of the ~~way towards~~ the ~~target each frame~~.		One of the most common behaviors implemented on dynamic cameras is the ability to follow a target, often the player.

			===Rigid Follow===
			The simplest implementation to achieve follow behavior is to rigidly lock your camera to the follow target. This was often done with early 2D games, where the camera would keep the player in the center of the screen at all times, unless the camera hit the scroll boundary of the map.

	<syntaxhighlight lang="cs">		<syntaxhighlight lang="cs">
Line 25:		Line 56:
	Vector3 FollowTarget;		Vector3 FollowTarget;
	Vector3 FollowOffset = Vector3.Zero;		Vector3 FollowOffset = Vector3.Zero;
	~~// FollowRate must be greater than zero.~~
	~~float FollowRate = 2.0f;~~

	void Update(float dt)		void Update(float dt)
	{		{
	~~// get vector to desired location~~		CameraPosition = FollowTarget + FollowOffset;
	~~var d~~ = FollowTarget + FollowOffset ~~- CameraPosition;~~
	~~var dsq = d.LengthSquared();~~
	~~CameraPosition += dsq > 1 ? d * FollowRate * dt : d~~;
	}		}
	</syntaxhighlight>		</syntaxhighlight>

	~~Note that there is a check for the camera being at a minimum distance from the target which snaps the camera into its equilibrium position.~~

	===Spring Damper===		===Spring Damper===
	Adding camera physics helps to smooth out the motion of the camera, and the simplest form of camera physics is a spring damper system. The following code simulates a critically damped spring damper system.		Sometimes the desired behavior is for the camera to trail behind the follow target. Adding camera physics helps to smooth out the motion of the camera, and the simplest form of camera physics is a spring damper system. The following code simulates a critically damped spring damper system.
	<syntaxhighlight lang="cs">		<syntaxhighlight lang="cs">
	Vector3 CameraPosition;		Vector3 CameraPosition;
Line 74:		Line 98:
	}		}
	</syntaxhighlight>		</syntaxhighlight>

			Note that there is a check for the camera being at a minimum distance from the target which snaps the camera into its equilibrium position.

	[[Category:Camera]]		[[Category:Camera]]

Winkio: /* Spring Damper */

2024-06-21T01:17:28Z

Spring Damper

← Older revision		Revision as of 21:17, 20 June 2024
Line 61:		Line 61:
	// apply acceleration to velocity		// apply acceleration to velocity
	CameraVelocity += CameraAcceleration * dt;		CameraVelocity += CameraAcceleration * dt;
	// ~~round velocity to zero~~ if both velocity and acceleration are near zero		// settle if both velocity and acceleration are near zero
	if (CameraVelocity.DistanceSquared() < 1 && CameraAcceleration.DistanceSquared() < 1)		if (CameraVelocity.DistanceSquared() < 1 && CameraAcceleration.DistanceSquared() < 1)
			{
	CameraVelocity = Vector2.Zero;		CameraVelocity = Vector2.Zero;
			CameraPosition = FollowTarget + FollowOffset;
			}
	// apply velocity to position		// apply velocity to position
	CameraPosition += CameraVelocity * dt;		else
			{
			CameraPosition += CameraVelocity * dt;
			}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

	[[Category:Camera]]		[[Category:Camera]]

Winkio at 19:34, 20 June 2024

2024-06-20T19:34:40Z

← Older revision		Revision as of 15:34, 20 June 2024
Line 19:		Line 19:

	===Interpolation===		===Interpolation===
			Sometimes the desired behavior is for the camera to trail behind the follow target. The simplest implementation for this behavior is to use interpolation to move the camera a percentage of the way towards the target each frame.

	<syntaxhighlight lang="cs">		<syntaxhighlight lang="cs">
	Vector3 CameraPosition;		Vector3 CameraPosition;
Line 34:		Line 36:
	}		}
	</syntaxhighlight>		</syntaxhighlight>

			Note that there is a check for the camera being at a minimum distance from the target which snaps the camera into its equilibrium position.

	===Spring Damper===		===Spring Damper===

Winkio at 14:24, 20 June 2024

2024-06-20T14:24:16Z

← Older revision		Revision as of 10:24, 20 June 2024
Line 1:		Line 1:
	A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place, or move dynamically, and many games have sophisticated camera systems that include collision and physics.		A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place or move dynamically, and many games have sophisticated camera systems that include collision and physics.

	==Follow==		==Follow==

Winkio at 23:15, 9 June 2024

2024-06-09T23:15:03Z

← Older revision		Revision as of 19:15, 9 June 2024
Line 65:		Line 65:
	</syntaxhighlight>		</syntaxhighlight>

	[[Category: Camera]]		[[Category:Camera]]

Winkio: /* Spring Damper */

2024-06-09T23:14:06Z

Spring Damper

← Older revision		Revision as of 19:14, 9 June 2024
Line 51:		Line 51:
	// Calculate the acceleration of the camera. This will be the sum of two terms:		// Calculate the acceleration of the camera. This will be the sum of two terms:
	// the spring acceleration which scales with distance from the target		// the spring acceleration which scales with distance from the target
	~~Vector2~~ AccelerationSpring = (FollowRate * FollowRate / 4) * d;		Vector3 AccelerationSpring = (FollowRate * FollowRate / 4) * d;
	// the damping acceleration which scales opposite the velocity of the camera		// the damping acceleration which scales opposite the velocity of the camera
	~~Vector2~~ AccelerationDamping = -1 * FollowRate * CameraVelocity;		Vector3 AccelerationDamping = -1 * FollowRate * CameraVelocity;
	~~Vector2~~ CameraAcceleration = AccelerationSpring + AccelerationDamping;		Vector3 CameraAcceleration = AccelerationSpring + AccelerationDamping;
	// apply acceleration to velocity		// apply acceleration to velocity
	CameraVelocity += CameraAcceleration * dt;		CameraVelocity += CameraAcceleration * dt;

Winkio: /* Spring Damper */

2024-06-09T22:50:44Z

Spring Damper

← Older revision		Revision as of 18:50, 9 June 2024
Line 36:		Line 36:

	===Spring Damper===		===Spring Damper===
			Adding camera physics helps to smooth out the motion of the camera, and the simplest form of camera physics is a spring damper system. The following code simulates a critically damped spring damper system.
	<syntaxhighlight lang="cs">		<syntaxhighlight lang="cs">
	Vector3 CameraPosition;		Vector3 CameraPosition;

Winkio at 22:47, 9 June 2024

2024-06-09T22:47:27Z

← Older revision		Revision as of 18:47, 9 June 2024
Line 1:		Line 1:
	A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place, or move dynamically, and many games have sophisticated camera systems that include collision and physics.		A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place, or move dynamically, and many games have sophisticated camera systems that include collision and physics.

			==Follow==
			One of the most common behaviors implemented on dynamic cameras is the ability to follow a target, often the player.

			===Rigid Follow===
			The simplest implementation to achieve follow behavior is to rigidly lock your camera to the follow target. This was often done with early 2D games, where the camera would keep the player in the center of the screen at all times, unless the camera hit the scroll boundary of the map.

			<syntaxhighlight lang="cs">
			Vector3 CameraPosition;
			Vector3 FollowTarget;
			Vector3 FollowOffset = Vector3.Zero;

			void Update(float dt)
			{
			CameraPosition = FollowTarget + FollowOffset;
			}
			</syntaxhighlight>

			===Interpolation===
			<syntaxhighlight lang="cs">
			Vector3 CameraPosition;
			Vector3 FollowTarget;
			Vector3 FollowOffset = Vector3.Zero;
			// FollowRate must be greater than zero.
			float FollowRate = 2.0f;

			void Update(float dt)
			{
			// get vector to desired location
			var d = FollowTarget + FollowOffset - CameraPosition;
			var dsq = d.LengthSquared();
			CameraPosition += dsq > 1 ? d * FollowRate * dt : d;
			}
			</syntaxhighlight>

			===Spring Damper===
			<syntaxhighlight lang="cs">
			Vector3 CameraPosition;
			Vector3 CameraVelocity;
			Vector3 FollowTarget;
			Vector3 FollowOffset = Vector3.Zero;
			// FollowRate must be greater than zero.
			float FollowRate = 2.0f;

			void Update(float dt)
			{
			// get vector to desired location
			var d = FollowTarget + FollowOffset - CameraPosition;
			// Calculate the acceleration of the camera. This will be the sum of two terms:
			// the spring acceleration which scales with distance from the target
			Vector2 AccelerationSpring = (FollowRate * FollowRate / 4) * d;
			// the damping acceleration which scales opposite the velocity of the camera
			Vector2 AccelerationDamping = -1 * FollowRate * CameraVelocity;
			Vector2 CameraAcceleration = AccelerationSpring + AccelerationDamping;
			// apply acceleration to velocity
			CameraVelocity += CameraAcceleration * dt;
			// round velocity to zero if both velocity and acceleration are near zero
			if (CameraVelocity.DistanceSquared() < 1 && CameraAcceleration.DistanceSquared() < 1)
			CameraVelocity = Vector2.Zero;
			// apply velocity to position
			CameraPosition += CameraVelocity * dt;
			}
			</syntaxhighlight>

	[[Category: Camera]]		[[Category: Camera]]

Winkio: Created page with "A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place, or move dynamically, and many games have sophisticated camera systems that include collision and physics. Category: Camera"

2024-06-09T22:24:24Z

Created page with "A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place, or move dynamically, and many games have sophisticated camera systems that include collision and physics. Category: Camera"

New page

A camera is an object with functionality that supports viewing the game world from a specific position and orientation. Cameras can be fixed in place, or move dynamically, and many games have sophisticated camera systems that include collision and physics.

[[Category: Camera]]