Operators

Once we know of the existence of variables, we can begin to operate with them. For that purpose, UnigineScript integrates operators. Operators are mostly made of signs that are not part of the alphabet but are available in all keyboards.

int a = 0, b = 0;
log.message("%d %d\n",++a,b++);
log.message("%d %d\n",++a,b++);
log.message("%d %d\n",a,b);

/* Output:
 * 1 0
 * 2 1
 * 2 2
 */

Scalar Operands

Vector Operands

String Operators

float a = -3.9;
string str = "there can be a mixture";
str = str + " of integer (" + 56 + ") and floating point values (" + a + ")";
log.message("%s\n", str);

/* Output: 
 * there can be a mixture of integer (56) and floating point values (-3.9)
 */

These operators take only the following types of variables as operands:

• int
• long

All non-zero values are equal to true, however, if true should be returned as a result of some operation, it will be always 1. false is always 0.

• Scalars of different types (int, long, float, double) can be freely comapared to each other, beacause of the automatic conversion of scalars.
• Vectors (vec3, vec4, dvec3, dvec4, ivec3, ivec4, mat4, quat) can only be compared with the same type.
  • vec3 can also be compared with dvec3 and vice versa.
  • vec4 can also be compared with dvec4 and vice versa.

If the statement is true, the operator returns 1, otherwise 0.

The conditional operator ?: can be used as a shorthand for what would normally be single-line blocks of the "if-then-else" construction. If used appropriately, this operator can enhance readability of code. Its syntax is the following: test_expression1 ? then_expression : else_expression.

int a = 10;
int b;
b = (a > 9) ? 100 : 200; // ternary operator usage

// this expression is equal to the previous one
if(a > 9) {
	b = 100;
} else {
	b = 200;
}
log.message("b =" + (b))
/* Output:
 * b = 200
 */

It is also possible to use the ?: operator in expressions. For example:

int a = 1;
int b = 2;
int c = 3;
int d = 4;

log.message("%s\n","test 1: " + (a == b) ? "a == b" : "a != b" + " final");
log.message("%s\n","test 2: " + ((c == d) ? "c == d" : "c != d") + " final");
log.message("%s\n","test 3: " + (a == b) ? "a == b and " + ((c == d) ? "c == d" : "c != d") : ("a != b and " + ((c == d) ? "c == d" : "c != d")));

test1: a != b final
test2: c != d final
test3: a != b and c != d

The assignment operator = can be combined with +, -, *, /, %, &, |, and ^. These combined operators (+=, -=, *=, /=, %=, &=, |=, and ^=) assign the result of the operation to the first operand (which must be a variable).

int a = 10;
int b, c;
a = b = c; // this won't work
a = b += c; // this won't work either

The type testing operator is serves to check the type of a given variable. The operator returns1 when:

• A given variable belongs to a specified type
• A given object is an instance of a specified class
• A given object is an instance of a class that derives from a specified class

The syntax of the operator is the following:

i is int

For example, this operator can be used in an if-else statement:

class Foo { };

class Bar : Foo { };

void check(int v) {
	string s = typeinfo(v);
	// both the is operator and the is_int() function check if v is of the int type
	if(v is int) log.message("%s is int\n",s);
	if(is_int(v)) log.message("%s is int\n",s);
	// check if v is of the float type
	if(v is float) log.message("%s is float\n",s);
	if(is_float(v)) log.message("%s is float\n",s);
	// check if v is an instance of the Stream class or class derived from the Stream
	if(v is Stream) log.message("%s is Stream\n",s);
	// check if v is an instance of the File class
	if(v is File) log.message("%s is File\n",s);
	// check if v is an instance of the Foo or Bar class
	if(v is Foo) log.message("%s is Foo\n",s);
	// check if v is an instance of the Bar class
	if(v is Bar) log.message("%s is Bar\n",s);
}

check(1);
check(1.0f);
check(new File());
check(new Foo());
check(new Bar());

int: 1 is int
int: 1 is int
float: 1 is int
float: 1 is int
File 000000000E9330E0 internal (5:0:0) is Stream
File 000000000E9330E0 internal (5:0:0) is File
Foo 000000000D06FCD0 (131072:0:0) is Foo
Bar 000000000D06FD00 (196608:0:0) is Foo
Bar 000000000D06FD00 (196608:0:0) is Bar

If an expression contains several operators, they will be evaluated in the order shown below, from the top to the bottom.

You can read about operator overloading here.