Once I get that upgrade to 36-hour days, I will tackle that. – Mychaeel
UE3:Object operators (UT3)
 |
Object (operators) |
Contents
- 1 Bool operators
- 2 Byte operators
- 3 Int operators
- 3.1 ++int
- 3.2 -int
- 3.3 --int
- 3.4 ~int
- 3.5 int++
- 3.6 int--
- 3.7 int * int
- 3.8 int / int
- 3.9 int + int
- 3.10 int - int
- 3.11 int << int
- 3.12 int >> int
- 3.13 int >>> int
- 3.14 int < int
- 3.15 int <= int
- 3.16 int == int
- 3.17 int > int
- 3.18 int >= int
- 3.19 int != int
- 3.20 int & int
- 3.21 int ^ int
- 3.22 int | int
- 3.23 int *= float
- 3.24 int += int
- 3.25 int -= int
- 3.26 int /= float
- 4 Float operators
- 4.1 -float
- 4.2 float ** float
- 4.3 float * float
- 4.4 float / float
- 4.5 float % float
- 4.6 float + float
- 4.7 float - float
- 4.8 float < float
- 4.9 float <= float
- 4.10 float == float
- 4.11 float > float
- 4.12 float >= float
- 4.13 float ~= float
- 4.14 float != float
- 4.15 float *= float
- 4.16 float += float
- 4.17 float -= float
- 4.18 float /= float
- 5 Vector operators
- 5.1 -vector
- 5.2 float * vector
- 5.3 vector * float
- 5.4 vector * vector
- 5.5 vector / float
- 5.6 vector Cross vector
- 5.7 vector Dot vector
- 5.8 vector + vector
- 5.9 vector - vector
- 5.10 vector << rotator
- 5.11 vector >> rotator
- 5.12 vector == vector
- 5.13 vector != vector
- 5.14 vector *= float
- 5.15 vector *= vector
- 5.16 vector += vector
- 5.17 vector -= vector
- 5.18 vector /= float
- 6 Rotator operators
- 7 Quat operators
- 8 Color operators
- 9 String operators
- 10 Name operators
- 11 Object operators
- Object operators in other games:
- RTNP, U1, UT, U2, U2XMP, UE2Runtime, UT2003, UT2004, UDK
- Other member categories for this class:
- static native functions, structs
Operators below are grouped by type and sorted by precedence.
Apart from the operators listed here, there are also a few implicitly declared operators, like assignment, generic struct (in)equality or the conditional operator.
Bool operators[edit]
!bool[edit]
Logical negation. Returns False if the parameter is True and vice versa.
bool == bool[edit]
Equality. Returns True if both parameters have the same value, otherwise False.
bool != bool[edit]
Inequality. Returns True if the parameters have different values, otherwise False
bool && bool[edit]
Logical AND. Returns True if both parameters are True, otherwise False.
This operator "short-circuits" if the first operand evaluates to False, i.e. in that case the second operand is not evaluated at all because the result is already known.
bool ^^ bool[edit]
Logical XOR. This is basically the same as the != operator, except that the inequality operator binds more tightly than XOR.
bool || bool[edit]
Logical OR. Returns True if any parameter is True, and False only if both parameters are False.
This operator "short-circuits" if the first operand evaluates to True, i.e. in that case the second operand is not evaluated at all because the result is already known.
Byte operators[edit]
++byte[edit]
Preincrement operator. The value of A is incremented by one and the result is returned.
--byte[edit]
Predecrement operator. The value of A is decremented by one and the result is returned.
byte++[edit]
Postincrement operator. The value of A is temporarily stored, then A is incremented by one and the original value is returned.
byte--[edit]
Postdecrement operator. The value of A is temporarily stored, then A is decremented by one and the original value is returned.
byte *= byte[edit]
Combined multiplication and assign for byte values. Multiplies A with B, stores the result in A and returns it.
byte *= float[edit]
Combined multiplication and assign. Multiplies A with B, stores the result in A and returns it. Performs floating point multiplication and typecasts the result to byte.
byte += byte[edit]
Combined add and assign. Adds A and B, stores the result in A and returns it.
byte -= byte[edit]
Combined subtract and assign. Subtracts B from A, stores the result in A and returns it.
byte /= byte[edit]
Combined divide and assign. Divides A by B, stores the result in A and returns it. Note that float values are automatically typecasted to byte for this operator:
local byte b; b = 10; b /= 2.5; // afterwards b is 5, not 4
If you need a floating point operation, use A *= 1.0 / B; instead.
Int operators[edit]
++int[edit]
Preincrement operator. The value of A is incremented by one and the result is returned.
-int[edit]
Arithmetic negation. The result is a number with the same magnitude, but opposite sign. For zero A the result obviously is 0. Note that this operator maps the smallest possible int number (-2147483648 or 0x80000000) onto itself because its positive counterpart is larger than the largest possible int number.
--int[edit]
Predecrement operator. The value of A is decremented by one and the result is returned.
~int[edit]
Bitwise NOT, or complement operator. Inverts all bits in the binary representation of A and returns that value.
int++[edit]
Postincrement operator. The value of A is temporarily stored, then A is incremented by one and the original value is returned.
int--[edit]
Postdecrement operator. The value of A is temporarily stored, then A is decremented by one and the original value is returned.
int * int[edit]
Integer multiplication. Multiplies A and B and returns the result.
int / int[edit]
Integer division. Divides A by B and returns the result. Any remainder after division is lost. Division by 0 is defined to return 0.
int + int[edit]
Integer addition. Adds A and B and returns the result.
int - int[edit]
Integer subtraction. Subtracts B from A and returns the result.
int << int[edit]
Arithmetic or logical left shift. Moves the bits in the binary representation of A to the left. Higher bits are "pushed out" to the left and from the right, zero bits are "pushed in". Arithmetic left shift corresponds to integer multiplication with 2B.
B is the distance to shift the bits. If it is negative or greater than 31, B is implicitly normalized to the range 0 to 31 as if by B & 0x1F.
int >> int[edit]
Arithmetic right shift. Moves the bits in the binary representation of A to the right. Lower bits are "pushed out" to the right and depending on the sign of the value, either 0 (for positive numbers) or 1 (for negative numbers) bits are "pushed in" from the left. Arithmetic right shift corresponds to integer division by 2B.
B is the distance to shift the bits. If it is negative or greater than 31, B is implicitly normalized to the range 0 to 31 as if by B & 0x1F.
int >>> int[edit]
Logical right shift. Moves the bits in the binary representation of A to the right. Higher bits are "pushed out" to the left and from the right, zero bits are "pushed in".
B is the distance to shift the bits. If it is negative or greater than 31, B is implicitly normalized to the range 0 to 31 as if by B & 0x1F.
int < int[edit]
Less-than comparison operator. Returns True if the value of A is less than the value of B.
int <= int[edit]
Less-or-equal comparison operator. Returns True if the value of A is less than or equal to the value of B.
int == int[edit]
Equality operator. Returns True if the value of A is equal to the value of B.
int > int[edit]
Greater-than comparison operator. Returns True if the value of A is greater than the value of B.
int >= int[edit]
Greater-or-equal comparison operator. Returns True if the value of A is greater than or equal to the value of B.
int != int[edit]
Inequality operator. Returns True if the value of A differs from the value of B.
int & int[edit]
Bitwise AND operator. Performs logical AND on each corresponding pair of bits from A and B and returns the result. Unlike the bool && bool operator, the bitwise AND operator always evaluates both operands.
int ^ int[edit]
Bitwise XOR operator. Performs logical XOR on each corresponding pair of bits from A and B and returns the result.
int | int[edit]
Bitwise OR operator. Performs logical OR on each corresponding pair of bits from A and B and returns the result. Unlike the logical OR operator, the bitwise OR operator always evaluates both operands.
int *= float[edit]
Combined multiply and assign. Multiplies A and B, stores the result in A and returns it.
Note: This operator always performs floating point multiplication and thus may be inaccurate for large values. If you need precision for large values, use A = A * B instead.
int += int[edit]
Combined add and assign. Adds A and B, stores the result in A and returns it.
int -= int[edit]
Combined subtract and assign. Subtracts B from A, stores the result in A and returns it.
int /= float[edit]
Combined divide and assign. Divides A by B, stores the result in A and returns it.
Note: This operator always performs floating point division and thus may be inaccurate for large values. If you need precision for large values, use A = A / B instead.
Float operators[edit]
Some floating point operators have the potential of overflowing the valid range of float values. If this happens, they return a "float error value". Such a value also propagates through operators and function calls if it is passed as a parameter.
-float[edit]
Arithmetic negation. The result is a number with the same magnitude, but opposite sign. For zero A the result obviously is 0.
float ** float[edit]
Exponentiation operator. Raises A to the power of B and returns the result. Attempting to raise a negative number to a fractional power results in NaN.
float * float[edit]
Floating point multiplication. Multiplies A and B and returns the result.
float / float[edit]
Floating point division. Divides A by B and returns the result. Division by zero results in NaN.
float % float[edit]
Remainder after (truncated) division, also called the modulo operator. Divides A by B and returns the remainder. Division by zero results in NaN. For negative values of A, the result is negative as well.
float + float[edit]
Floating point addition. Adds A and B and returns the result.
float - float[edit]
Floating point subtraction. Subtracts B from A and returns the result.
float < float[edit]
Less-than comparison operator. Returns True if the value of A is less than the value of B.
float <= float[edit]
Less-or-equal comparison operator. Returns True if the value of A is less than or equal to the value of B.
float == float[edit]
Equality comparison operator. Returns True if the value of A is equal to the value of B.
float > float[edit]
Greater-than comparison operator. Returns True if the value of A is greater than to the value of B.
float >= float[edit]
Greater-or-equal comparison operator. Returns True if the value of A is greater than or equal to the value of B.
float ~= float[edit]
Approximately-equal comparison operator. Returns True if the values of A and B differ by less than 0.0001.
float != float[edit]
Inequality comparison operator. Returns True if the value of A is different from the value of B.
float *= float[edit]
Combined multiply and assign. Multiplies A and B, stores the result in A and returns it.
float += float[edit]
Combined add and assign. Adds A and B, stores the result in A and returns it.
float -= float[edit]
Combined subtract and assign. Subtracts B from A, stores the result in A and returns it.
float /= float[edit]
Combined divide and assign. Divides A by B, stores the result in A and returns it.
Vector operators[edit]
-vector[edit]
Inverts the vector by negating its components. The resulting vector has the same length, but points in the opposite direction.
float * vector[edit]
Multiplies the vector's components by a scalar value. The resulting vector's length it the original vector's length multiplied by the absolute value of the scalar. Its direction is the same if the scalar is positive and inversed if the scalar is negative.
vector * float[edit]
Same as float * vector, just with swapped operands.
vector * vector[edit]
Multiplies the corresponding components of the two vectors and returns them as the corresponding commponents of the resulting vector.
vector / float[edit]
Divides the vector's components by a scalar value. The resulting vector's length it the original vector's length divided by the absolute value of the scalar. Its direction is the same if the scalar is positive and inversed if the scalar is negative.
vector Cross vector[edit]
Calculates the cross product of the two vectors. The result is a vector perpenticular to both input vectors. Its length is equal to the area of the parallelogram described by the two vectors.
vector Dot vector[edit]
Calculates the dot product of the two vectors. The result is a scalar value, the sum of the products of corresponding components of the two vectors.
vector + vector[edit]
Adds the two vectors' corresponding components. The resulting vector can be constructed geometrically by attaching the initial point of vector B to the endpoint of vector A. Now the vector starting at the initial point of A and ending at the endpoint of B has the same length and orientation as the resulting vector.
vector - vector[edit]
Subtracts the components of vector B from the corresponding components of vector A. The resulting vector can be constructed geometrically by attaching the endpoint of vector B to the endpoint of vector A. Now the vector starting at the initial point of A and ending at the initial point of vector B has the same length and orientation as the resulting vector.
vector << rotator[edit]
Vector local-to-global transformation. Imagine a "view offset" vector, e.g. for the weapon in 1st-person view. Such a vector value describes an offset for when the camera points in positive world X-axis direction, with the camera's "up" direction being the same as the world's "up" direction. Now imagine the camera is oriented a different way and the view offset vector needs to be transformed to world coordinates. This is exactly what OffsetVector << CameraRotation does.
Often the GetAxes() function is used for the same transformation:
local vector CamX, CamY, CamZ, Result; GetAxes(CameraRotation, CamX, CamY, CamZ); Result = OffsetVector.X * CamX + OffsetVector.Y * CamY + OffsetVector.Z * CamZ;
vector >> rotator[edit]
Vector global-to-local transformation. This operation is the reverse of the vector << rotator operator, as it could be used to transform an offset vector from world coordinates to local camera coordinates. The code example would be largely the same, except that GetUnAxes() would be used,
vector == vector[edit]
Vector equality operator. Returns True if both vectors have the same length and orientation, which can only be true if their corresponding components are equal.
vector != vector[edit]
Vector inequality operator. Returns True if the two vectors differ in length or orientation, which happens if any of the corresponding components are different.
vector *= float[edit]
Combined scalar multiply and assign. Multiplies vector A by scalar value B, stores the result in A and returns it.
vector *= vector[edit]
Combined vector component multiply and assign. Multiplies the corresponding components of A and B, stores the resulting vector in A and returns is.
vector += vector[edit]
Combined vector add and assign. Adds A and B, stores the resulting vector in A and returns it.
vector -= vector[edit]
Combined vector subtract and assign. Subtracts B from A, stores the resulting vector in A and returns it.
vector /= float[edit]
Combined scalar divide and assign. Divides vector A by scalar B, stores the result in A and returns it.
Rotator operators[edit]
float * rotator[edit]
Multiplies each component of the rotator with the float value and returns the resulting rotator. This operator probably makes more sense for rotation rates than for object orientations. Note that rotator components are of type int, so the results will have their fractional part truncated.
rotator * float[edit]
Same as float * rotator, just with the operands swapped.
rotator / float[edit]
Divides each component of the rotator by the float value and returns the resulting rotator. This operator probably makes more sense for rotation rates than for object orientations. Note that rotator components are of type int, so the results will have their fractional part truncated.
rotator + rotator[edit]
Adds the corresponding components of the rotators and returns the resulting rotator.
rotator - rotator[edit]
Subtracts the component values of B from the corresponding components of A and returns the resulting rotator.
rotator == rotator[edit]
Rotator equality. Returns True if the corresponding components of the two rotators have identical values. To compare rotators for orientation, if may be necessary to Normalize() their components first. Sometimes that doesn't work either: for example rot(0,32768,0) != rot(32768,0,32768) even though these two rotator literals actually have the same effect if used e.g. as camera rotation.
int ClockwiseFrom int[edit]
Compares corresponding normalized component values of two rotators and returns True if the shortest rotation direction from A to B would be in clockwise direction, i.e. by incrementing A until it reaches B.
Yes, this is actually an int operator returning a bool result. It is listed here among the rotator operators nonetheless because its use it closely related to rotators.
rotator != rotator[edit]
Rotator inequality. Returns True if any corresponding components of the two rotators differ. As mentioned for the == operator above, this doesn't necessarily mean that the rotators represent different orientations.
rotator *= float[edit]
Combined rotator multiply and assign. Multiplies each component of rotator A by B, stores the result in A and returns it.
rotator += rotator[edit]
Combined rotator add and assign. Adds the corresponding components of rotators A and B, stores the result in A and returns it.
rotator -= rotator[edit]
Combined rotator subtract and assign. Subtracts the components of rotator B from the corresponding components of A, stores the result in A and returns it.
rotator /= float[edit]
Combined rotator divide and assign. Divides each component of rotator A by B, stores the result in A and returns it.
Quat operators[edit]
Note: Use Quaternion functions if you want to combine Quat values in more meaningful ways.
Quat + Quat[edit]
Adds the two quaternions' corresponding components.
Quat - Quat[edit]
Subtracts the components of quaternion B from the corresponding components of quaternion A.
Color operators[edit]
color * float[edit]
Multiplies the RGB components of the color with the float value and returns the resulting color with the original alpha value. Note that color components are of type byte, so the results will be modulo 256 and have their fractional part truncated.
float * color[edit]
Same as color * float, just with the operands swapped.
LinearColor * float[edit]
Multiplies the RGB components of the color with the float value and returns the resulting color with the original alpha value.
color + color[edit]
Adds the RGB components of the colors and returns the resulting color with the original alpha value of color A. Note that color components are of type byte, so the results will be modulo 256.
color - color[edit]
Subtracts the second color's RGB components from the first's and returns the resulting color with the original alpha value of color A. Note that color components are of type byte, so the results will be modulo 256.
LinearColor - LinearColor[edit]
Subtracts the second color's RGB components from the first's and returns the resulting color with the original alpha value of color A.
String operators[edit]
string < string[edit]
Compares the strings case-sensitively and returns True if A comes before B in lexicographical order.
string <= string[edit]
Compares the strings case-sensitively and returns True if A is identical to B or comes before B in lexicographical order.
string == string[edit]
Case-sensitive string equality. Returns True if A and B contain the exact same characters in exactly the same order.
string > string[edit]
Compares the strings case-sensitively and returns True if A comes after B in lexicographical order.
string >= string[edit]
Compares the strings case-sensitively and returns True if A is identical to B or comes after B in lexicographical order.
string ~= string[edit]
Case-insensitive string equality. Returns True if the two strings are either equal or only differ by case.
string != string[edit]
Case-sensitive string inequality. Returns True if the strings do not contain the exact same characters in exactly the same order. This includes different case.
To compare two strings for case-insensitive inequality you can either compare their capitalized versions for inequality (Caps(A) != Caps(B)) or negate the result of the case-insensitive equality operator (!(A ~= B)).
string $ string[edit]
String concatenation. Returns a string that contains the content of B appended to the content of A: "Hello" $ "World" results in the string "HelloWorld".
string @ string[edit]
Spaced string concatenation. Same as string $ string, but the two strings are separated by a space character in the result: "Hello" @ "World" results in the string "Hello World".
string $= string[edit]
Combined concate and assign. Appends the content of B to A, stores the result in A and returns it.
string @= string[edit]
Combined spaced concate and assign. Appends a space character and the content of B to A, stores the result in A and returns it.
string -= string[edit]
Combined string removal and assign. Finds all occurrences of B in A and removes them. The result is stored in A and returned. Occurences of B that are a result of a removal operation are ignored: "aaabbb" -= "ab" results in "aabb".
Name operators[edit]
name == name[edit]
Name equality. Returns True if A and B represent the same name value.
name != name[edit]
Name inequality. Returns True if A and B represent different name value.
Object operators[edit]
Interface == Interface[edit]
Object equality if interface-type variables are involved.. Returns True if A and B either point to the same object or are both None.
Object == Object[edit]
Object equality. Returns True if A and B either point to the same object or are both None.
Interface != Interface[edit]
Object inequality if interface-type variables are involved. Returns True if A and B point to different objects or one is None while the other isn't.
Object != Object[edit]
Object inequality. Returns True if A and B point to different objects or one is None while the other isn't.
