Vector - Revision history

113.22.251.171: /* More vector length3 */ Changed "squard" to "squared".

2011-04-20T10:32:05Z

‎More vector length3: Changed "squard" to "squared".

Wormbo: added vector transformation operators

2011-03-04T14:32:51Z

added vector transformation operators

Wormbo: /* Vector scaling */ linked Wikipedia NaN

2011-02-10T17:42:21Z

‎Vector scaling: linked Wikipedia NaN

Wormbo: /* Vector operations */ added some wikipedia links

2011-02-10T17:40:00Z

‎Vector operations: added some wikipedia links

Wormbo: info about practical limits to vector values in maps and for replication

2010-07-13T21:19:30Z

info about practical limits to vector values in maps and for replication

Wormbo: /* Vector scaling */ note about vector division by zero

2010-06-08T09:42:06Z

‎Vector scaling: note about vector division by zero

Wormbo: /* Mirroring vectors */ "size doesn't matter" ;-)

2010-03-15T16:45:26Z

‎Mirroring vectors: "size doesn't matter" ;-)

Wormbo: /* Vector length and unit vector */ Normal(vect(0,0,0)) == vect(0,0,0)

2010-01-15T19:02:33Z

‎Vector length and unit vector: Normal(vect(0,0,0)) == vect(0,0,0)

Eliot at 03:30, 30 December 2009

2009-12-30T03:30:36Z

Eliot: Added navbox, not sure if this one is supposed to have one.

2009-12-30T03:28:45Z

Added navbox, not sure if this one is supposed to have one.

@@ Line 51: / Line 51: @@
 ====More vector length<sup>3</sup>====
-The standard vector length calculation involves taking the square root of the sum of squared vector component values. In [[Unreal Engine 3]] you can also drop the square root operation and get the squared vector length via the <code>VSizeSq()</code> function. For example if you only want to compare vector lengths, this function is a bit faster. If the engine version you use doesn't provide the squard vector size function, don't bother creating it in UnrealScript just for performance reasons, any UnrealScript implementation would be slower than <code>VSize()</code> itself. If, however, you want to create it because you need the value, you can choose between the expressions <code>Square(VSize(''X''))</code> and <code>''X'' dot ''X''</code>, which are equivalent.
+The standard vector length calculation involves taking the square root of the sum of squared vector component values. In [[Unreal Engine 3]] you can also drop the square root operation and get the squared vector length via the <code>VSizeSq()</code> function. For example if you only want to compare vector lengths, this function is a bit faster. If the engine version you use doesn't provide the squared vector size function, don't bother creating it in UnrealScript just for performance reasons, any UnrealScript implementation would be slower than <code>VSize()</code> itself. If, however, you want to create it because you need the value, you can choose between the expressions <code>Square(VSize(''X''))</code> and <code>''X'' dot ''X''</code>, which are equivalent.
 Testing for the zero vector can be done using the <code>IsZero()</code> function. This is a bit more efficient than explicitly comparing a vector value to a zero [[Literals#Vectors|vector literal]]. (<code>''X'' == vect(0,0,0)</code>)

@@ Line 70: / Line 70: @@
 ===Mirroring vectors===
 There's a convenient mirroring function called <code>MirrorVectorByNormal()</code> that takes two parameters. The first parameter is the vector you want to mirror and the second is the [[wp:surface normal|surface normal]] vector of a plane will "reflect" your vector. The direction (towards or away from your vector) and length do not matter, as long as the length is not zero.
 ===Vector projection<sup>3</sup>===

@@ Line 29: / Line 29: @@
 Multiplication by -1 can be expressed with the preoperator <code>-</code> and corresponds to reversing the vectors direction without changing its length.
-'''Note:''' It is possible to divide vectors by zero. Like for other float values divided by zero, the resulting vector's components will contain an error value. Such an error value will propagate through all vector operations, causing the results to be error values as well. Be very careful about error values ending up in [[Actor]] locations, velocities or accelerations, as these may cause the engine to crash in weird ways! Fortunately there are only few other operations (e.g. <code>Sqrt()</code> or <code>Loge()</code>) capable of producing such "invalid" float values.
+'''Note:''' It is possible to divide vectors by zero. Like for other float values divided by zero, the resulting vector's components will contain an [[wp:NaN|error value]]. Such an error value will propagate through all vector operations, causing the results to be error values as well. Be very careful about error values ending up in [[Actor]] locations, velocities or accelerations, as these may cause the engine to crash in weird ways! Fortunately there are only few other operations (e.g. <code>Sqrt()</code> or <code>Loge()</code>) capable of producing such "invalid" float values.
 ===Dot product===

@@ Line 23: / Line 23: @@
 ===Vector scaling===
-Vector scaling corresponds to multiplication or division by a scalar (i.e. [[float]]) value. Multiplying (or dividing) by negative values reverses the vector's direction. Values other than 1 (and -1) change the length of the vector.
+[[wp:Euclidean vector#Scalar_multiplication|Vector scaling]] corresponds to multiplication or division by a scalar (i.e. [[float]]) value. Multiplying (or dividing) by negative values reverses the vector's direction. Values other than 1 (and -1) change the length of the vector.
 Vectors can be multiplied and divided by scalar (i.e. [[float]]) values via the <code>*</code> and <code>/</code> operators. Scalar multiplication is commutative (<code>sVal * vVal == vVal * sVal</code>), but scalar division is only defined as vector divided by scalar. Scalar multiplication and division is defined as component-wise multiplication and division by the scalar value respectively.
@@ Line 32: / Line 32: @@
 ===Dot product===
-The dot product of two vectors, also called inner product or scalar product, is defined as the sum of the products of corresponding components of the two vectors.<br/>In UnrealScript this is done with the operator <code>Dot</code>.
+The [[wp:dot product|dot product]] of two vectors, also called inner product or scalar product, is defined as the sum of the products of corresponding components of the two vectors.<br/>In UnrealScript this is done with the operator <code>Dot</code>.
 By definition, the dot product of perpendicular vectors is zero. The dot product is negative if the vectors point in relatively opposite directions (more than 90 degrees) and positive if they point in relatively similar directions. (less than 90 degrees) Applied to unit vectors, the dot product is exactly the cosine of the angle between the two vectors.
 ===Cross product===
-The cross product of two 3D vectors, also called the outer product or vector product, is defined as a vector whose length is equal to the area of the parallelogram formed by the two vectors, and that is perpendicular to each of the two vectors. The cross product is not commutative, exchanging the operands inverts the direction of the resulting vector: a×b = -(b×a).
+The [[wp:cross product|cross product]] of two 3D vectors, also called the outer product or vector product, is defined as a vector whose length is equal to the area of the parallelogram formed by the two vectors, and that is perpendicular to each of the two vectors. The cross product is not commutative, exchanging the operands inverts the direction of the resulting vector: a×b = -(b×a).
 UnrealScript provides the operator <code>Cross</code> for calculating the cross product. The directions of the two operands and the result of the cross product can be determined by the ''right hand rule'':
@@ Line 48: / Line 48: @@
 ===Vector length and unit vector===
-To get the length of a vector, you can use the <code>VSize()</code> function. To normalize a vector's length to 1 without changing its orientation, you can use the <code>Normal()</code> function. The null vector <code>vect(0,0,0)</code> does not have an orientation by definition, so trying to normalize it does not have any effect.
+To get the [[wp:Euclidean vector#Length|length of a vector]], you can use the <code>VSize()</code> function. To [[wp:unit vector|normalize]] a vector's length to 1 without changing its orientation, you can use the <code>Normal()</code> function. The null vector <code>vect(0,0,0)</code> does not have an orientation by definition, so trying to normalize it does not have any effect.
 ====More vector length<sup>3</sup>====

← Older revision		Revision as of 21:19, 13 July 2010
Line 1:		Line 1:
	The type '''vector''' is not a built-in type, but a [[struct]] defined in the {{classgames\|Object}} class of all Unreal Engine games. Conceptually it corresponds to a three-dimensional [[wp:euclidean vector\|euclidean vector]] and the Object class defines many functions and operators for working with vector values. The importance of the vector struct is stressed by the fact that it is one of only two struct types whose values can be specified directly using a [[Literals#Vectors\|literal]].		The type '''vector''' is not a built-in type, but a [[struct]] defined in the {{classgames\|Object}} class of all Unreal Engine games. Conceptually it corresponds to a three-dimensional [[wp:euclidean vector\|euclidean vector]] and the Object class defines many functions and operators for working with vector values. The importance of the vector struct is stressed by the fact that it is one of only two struct types whose values can be specified directly using a [[Literals#Vectors\|literal]].
		+
		+	Vector components use [[wp:single precision floating-point format\|single precision floating-point format]], which imposes a practical limit to level sizes. The maximum floating point accuracy is about 7 digits in total. Considering you will most likely want at least 2 or 3 digits after the decimal point to get smooth player movement, the play area of a map should not exceed about ±100000 [[Unreal Unit]]s on each coordinate axis. Static environment can exist a bit further away, since it doesn't require smooth location updates.
		+
		+	'''Important:''' The vector struct's components are rounded to integers for [[replication]]. Additionally, the values may not exceed the range of about ±1000000 or they will overflow. If you need to replicate vectors with fractional precision or larger values, consider scaling the vector value for replication.

	'''Note:''' [[Unreal Engine 3]] games may also define other vector-like structs, such as [[UE3:Object structs (UT3)#Vector2D\|Vector2D]] or [[UE3:Object structs (UT3)#Vector4\|Vector4]]. In theory, many operations described in this article can also be applied to two- and four-dimensional vectors, but most of them are only defined for three-dimensional vectors (i.e. the ''Vector'' struct) in the engine. See the functions and operators defined in Object and other classed of your game to see which operations are available for the data type you want to use.		'''Note:''' [[Unreal Engine 3]] games may also define other vector-like structs, such as [[UE3:Object structs (UT3)#Vector2D\|Vector2D]] or [[UE3:Object structs (UT3)#Vector4\|Vector4]]. In theory, many operations described in this article can also be applied to two- and four-dimensional vectors, but most of them are only defined for three-dimensional vectors (i.e. the ''Vector'' struct) in the engine. See the functions and operators defined in Object and other classed of your game to see which operations are available for the data type you want to use.

← Older revision		Revision as of 09:42, 8 June 2010
Line 24:		Line 24:

	Multiplication by -1 can be expressed with the preoperator <code>-</code> and corresponds to reversing the vectors direction without changing its length.		Multiplication by -1 can be expressed with the preoperator <code>-</code> and corresponds to reversing the vectors direction without changing its length.
		+
		+	'''Note:''' It is possible to divide vectors by zero. Like for other float values divided by zero, the resulting vector's components will contain an error value. Such an error value will propagate through all vector operations, causing the results to be error values as well. Be very careful about error values ending up in [[Actor]] locations, velocities or accelerations, as these may cause the engine to crash in weird ways! Fortunately there are only few other operations (e.g. <code>Sqrt()</code> or <code>Loge()</code>) capable of producing such "invalid" float values.

	===Dot product===		===Dot product===

@@ Line 81: / Line 81: @@
 * [[Rotator]]
 * [[Quaternion]]
 {{navbox unrealscript}}

← Older revision		Revision as of 03:28, 30 December 2009
Line 83:		Line 83:

	[[Category:Programming articles]]		[[Category:Programming articles]]
		+
		+	{{navbox unrealscript}}