public static global::glm.Vec3 addVec(global::glm.Vec3 a, global::glm.Vec3 b, global::glm.Vec3 dest)
{
dest.x = (a.x + b.x);
dest.y = (a.y + b.y);
dest.z = (a.z + b.z);
return(dest);
}
public static global::glm.Vec3 addScalar(global::glm.Vec3 a, double s, global::glm.Vec3 dest)
{
dest.x = (a.x + s);
dest.y = (a.y + s);
dest.z = (a.z + s);
return(dest);
}
public static global::glm.Vec3 subtractVec(global::glm.Vec3 a, global::glm.Vec3 b, global::glm.Vec3 dest)
{
dest.x = (a.x - b.x);
dest.y = (a.y - b.y);
dest.z = (a.z - b.z);
return(dest);
}
public static global::glm.Vec3 multiplyScalar(global::glm.Vec3 a, double s, global::glm.Vec3 dest)
{
dest.x = (a.x * s);
dest.y = (a.y * s);
dest.z = (a.z * s);
return(dest);
}
public static global::glm.Mat4 transform(global::glm.Vec3 translation, global::glm.Quat rotation, global::glm.Vec3 scale, global::glm.Mat4 dest)
{
unchecked {
double x2 = (rotation.x + rotation.x);
double y2 = (rotation.y + rotation.y);
double z2 = (rotation.z + rotation.z);
double xx = (rotation.x * x2);
double xy = (rotation.x * y2);
double xz = (rotation.x * z2);
double yy = (rotation.y * y2);
double yz = (rotation.y * z2);
double zz = (rotation.z * z2);
double wx = (rotation.w * x2);
double wy = (rotation.w * y2);
double wz = (rotation.w * z2);
dest._00 = (((1 - ((yy + zz)))) * scale.x);
dest._01 = (((xy + wz)) * scale.x);
dest._02 = (((xz - wy)) * scale.x);
dest._03 = ((double)(0));
dest._10 = (((xy - wz)) * scale.y);
dest._11 = (((1 - ((xx + zz)))) * scale.y);
dest._12 = (((yz + wx)) * scale.y);
dest._13 = ((double)(0));
dest._20 = (((xz + wy)) * scale.z);
dest._21 = (((yz - wx)) * scale.z);
dest._22 = (((1 - ((xx + yy)))) * scale.z);
dest._23 = ((double)(0));
dest._30 = translation.x;
dest._31 = translation.y;
dest._32 = translation.z;
dest._33 = ((double)(1));
return(dest);
}
}
public static global::glm.Mat4 translate(global::glm.Vec3 translation, global::glm.Mat4 dest)
{
unchecked {
{
dest._00 = ((double)(1));
dest._10 = ((double)(0));
dest._20 = ((double)(0));
dest._30 = ((double)(0));
dest._01 = ((double)(0));
dest._11 = ((double)(1));
dest._21 = ((double)(0));
dest._31 = ((double)(0));
dest._02 = ((double)(0));
dest._12 = ((double)(0));
dest._22 = ((double)(1));
dest._32 = ((double)(0));
dest._03 = ((double)(0));
dest._13 = ((double)(0));
dest._23 = ((double)(0));
dest._33 = ((double)(1));
}
dest._30 = translation.x;
dest._31 = translation.y;
dest._32 = translation.z;
return(dest);
}
}
public static global::glm.Vec3 copy(global::glm.Vec3 src, global::glm.Vec3 dest)
{
dest.x = src.x;
dest.y = src.y;
dest.z = src.z;
return(dest);
}
public static global::glm.Mat4 scale(global::glm.Vec3 amount, global::glm.Mat4 dest)
{
unchecked {
{
dest._00 = ((double)(1));
dest._10 = ((double)(0));
dest._20 = ((double)(0));
dest._30 = ((double)(0));
dest._01 = ((double)(0));
dest._11 = ((double)(1));
dest._21 = ((double)(0));
dest._31 = ((double)(0));
dest._02 = ((double)(0));
dest._12 = ((double)(0));
dest._22 = ((double)(1));
dest._32 = ((double)(0));
dest._03 = ((double)(0));
dest._13 = ((double)(0));
dest._23 = ((double)(0));
dest._33 = ((double)(1));
}
dest._00 = amount.x;
dest._11 = amount.y;
dest._22 = amount.z;
return(dest);
}
}
public static global::glm.Vec3 subtractVecOp(global::glm.Vec3 a, global::glm.Vec3 b)
{
global::glm.Vec3 dest = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
dest.x = (a.x - b.x);
dest.y = (a.y - b.y);
dest.z = (a.z - b.z);
return(dest);
}
public global::glm.Vec3 subtract(global::glm.Vec3 v)
{
global::glm.Vec3 dest = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
dest.x = (this.x - v.x);
dest.y = (this.y - v.y);
dest.z = (this.z - v.z);
return(dest);
}
public static global::glm.Vec3 addScalarOp(global::glm.Vec3 a, double s)
{
global::glm.Vec3 dest = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
dest.x = (a.x + s);
dest.y = (a.y + s);
dest.z = (a.z + s);
return(dest);
}
public static double angleBetween(global::glm.Vec3 a, global::glm.Vec3 b)
{
double dot = (((a.x * b.x) + (a.y * b.y)) + (a.z * b.z));
dot /= (global::System.Math.Sqrt(((double)((((a.x * a.x) + (a.y * a.y)) + (a.z * a.z))))) * global::System.Math.Sqrt(((double)((((b.x * b.x) + (b.y * b.y)) + (b.z * b.z))))));
double angle = global::System.Math.Acos(((double)(dot)));
return(angle);
}
public static void __hx_ctor_glm_Vec3(global::glm.Vec3 __hx_this, global::haxe.lang.Null <double> x, global::haxe.lang.Null <double> y, global::haxe.lang.Null <double> z)
{
double __temp_z50 = ((!(z.hasValue)) ? (((double)(0))) : ((z).@value));
double __temp_y49 = ((!(y.hasValue)) ? (((double)(0))) : ((y).@value));
double __temp_x48 = ((!(x.hasValue)) ? (((double)(0))) : ((x).@value));
__hx_this.x = __temp_x48;
__hx_this.y = __temp_y49;
__hx_this.z = __temp_z50;
}
public static global::glm.Vec3 @set(global::glm.Vec3 dest, global::haxe.lang.Null <double> x, global::haxe.lang.Null <double> y, global::haxe.lang.Null <double> z)
{
double __temp_z47 = ((!(z.hasValue)) ? (((double)(0))) : ((z).@value));
double __temp_y46 = ((!(y.hasValue)) ? (((double)(0))) : ((y).@value));
double __temp_x45 = ((!(x.hasValue)) ? (((double)(0))) : ((x).@value));
dest.x = __temp_x45;
dest.y = __temp_y46;
dest.z = __temp_z47;
return(dest);
}
public static global::glm.Vec3 divideScalarOp(global::glm.Vec3 a, double s)
{
unchecked {
double s1 = (1 / s);
global::glm.Vec3 dest = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
dest.x = (a.x * s1);
dest.y = (a.y * s1);
dest.z = (a.z * s1);
return(dest);
}
}
public static global::glm.Vec3 multVec(global::glm.Mat3 m, global::glm.Vec3 v, global::glm.Vec3 dest)
{
double x = v.x;
double y = v.y;
double z = v.z;
dest.x = (((m._00 * x) + (m._10 * y)) + (m._20 * z));
dest.y = (((m._01 * x) + (m._11 * y)) + (m._21 * z));
dest.z = (((m._02 * x) + (m._12 * y)) + (m._22 * z));
return(dest);
}
public static global::glm.Quat axisAngle(global::glm.Vec3 axis, double angle, global::glm.Quat dest)
{
angle *= 0.5;
double s = global::System.Math.Sin(((double)(angle)));
dest.x = (s * axis.x);
dest.y = (s * axis.y);
dest.z = (s * axis.z);
dest.w = global::System.Math.Cos(((double)(angle)));
return(dest);
}
public static global::glm.Vec3 multVecOp(global::glm.Mat3 m, global::glm.Vec3 v)
{
global::glm.Vec3 dest = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
double x = v.x;
double y = v.y;
double z = v.z;
dest.x = (((m._00 * x) + (m._10 * y)) + (m._20 * z));
dest.y = (((m._01 * x) + (m._11 * y)) + (m._21 * z));
dest.z = (((m._02 * x) + (m._12 * y)) + (m._22 * z));
return(dest);
}
public static global::glm.Vec3 lerp(global::glm.Vec3 a, global::glm.Vec3 b, double t, global::glm.Vec3 dest)
{
double a1 = a.x;
dest.x = (a1 + (t * ((b.x - a1))));
double a2 = a.y;
dest.y = (a2 + (t * ((b.y - a2))));
double a3 = a.z;
dest.z = (a3 + (t * ((b.z - a3))));
return(dest);
}
public static global::glm.Vec3 normalize(global::glm.Vec3 v, global::glm.Vec3 dest)
{
unchecked {
double length = global::System.Math.Sqrt(((double)((((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)))));
double mult = ((double)(0));
if ((length >= global::glm.GLM.EPSILON))
{
mult = (1 / length);
}
dest.x = (v.x * mult);
dest.y = (v.y * mult);
dest.z = (v.z * mult);
return(dest);
}
}
public static global::glm.Vec3 rotateVec3(global::glm.Quat q, global::glm.Vec3 v, global::glm.Vec3 dest)
{
double num12 = (q.x + q.x);
double num2 = (q.y + q.y);
double num = (q.z + q.z);
double num11 = (q.w * num12);
double num10 = (q.w * num2);
double num9 = (q.w * num);
double num8 = (q.x * num12);
double num7 = (q.x * num2);
double num6 = (q.x * num);
double num5 = (q.y * num2);
double num4 = (q.y * num);
double num3 = (q.z * num);
double num15 = (((v.x * (((1.0 - num5) - num3))) + (v.y * ((num7 - num9)))) + (v.z * ((num6 + num10))));
double num14 = (((v.x * ((num7 + num9))) + (v.y * (((1.0 - num8) - num3)))) + (v.z * ((num4 - num11))));
double num13 = (((v.x * ((num6 - num10))) + (v.y * ((num4 + num11)))) + (v.z * (((1.0 - num8) - num5))));
dest.x = num15;
dest.y = num14;
dest.z = num13;
return(dest);
}
public global::glm.Vec3 rotate(global::glm.Vec3 v)
{
global::glm.Vec3 dest = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
double num12 = (this.x + this.x);
double num2 = (this.y + this.y);
double num = (this.z + this.z);
double num11 = (this.w * num12);
double num10 = (this.w * num2);
double num9 = (this.w * num);
double num8 = (this.x * num12);
double num7 = (this.x * num2);
double num6 = (this.x * num);
double num5 = (this.y * num2);
double num4 = (this.y * num);
double num3 = (this.z * num);
double num15 = (((v.x * (((1.0 - num5) - num3))) + (v.y * ((num7 - num9)))) + (v.z * ((num6 + num10))));
double num14 = (((v.x * ((num7 + num9))) + (v.y * (((1.0 - num8) - num3)))) + (v.z * ((num4 - num11))));
double num13 = (((v.x * ((num6 - num10))) + (v.y * ((num4 + num11)))) + (v.z * (((1.0 - num8) - num5))));
dest.x = num15;
dest.y = num14;
dest.z = num13;
return(dest);
}
public static global::glm.Mat4 lookAt(global::glm.Vec3 eye, global::glm.Vec3 centre, global::glm.Vec3 up, global::glm.Mat4 dest)
{
unchecked {
global::glm.Vec3 dest1 = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
dest1.x = (centre.x - eye.x);
dest1.y = (centre.y - eye.y);
dest1.z = (centre.z - eye.z);
global::glm.Vec3 f = dest1;
{
double length = global::System.Math.Sqrt(((double)((((f.x * f.x) + (f.y * f.y)) + (f.z * f.z)))));
double mult = ((double)(0));
if ((length >= global::glm.GLM.EPSILON))
{
mult = (1 / length);
}
{
f.x *= mult;
f.y *= mult;
f.z *= mult;
}
}
global::glm.Vec3 dest2 = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
dest2 = new global::glm.Vec3(new global::haxe.lang.Null <double>(((f.y * up.z) - (f.z * up.y)), true), new global::haxe.lang.Null <double>(((f.z * up.x) - (f.x * up.z)), true), new global::haxe.lang.Null <double>(((f.x * up.y) - (f.y * up.x)), true));
global::glm.Vec3 s = dest2;
{
double length1 = global::System.Math.Sqrt(((double)((((s.x * s.x) + (s.y * s.y)) + (s.z * s.z)))));
double mult1 = ((double)(0));
if ((length1 >= global::glm.GLM.EPSILON))
{
mult1 = (1 / length1);
}
{
s.x *= mult1;
s.y *= mult1;
s.z *= mult1;
}
}
global::glm.Vec3 dest3 = new global::glm.Vec3(default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>), default(global::haxe.lang.Null <double>));
dest3 = new global::glm.Vec3(new global::haxe.lang.Null <double>(((s.y * f.z) - (s.z * f.y)), true), new global::haxe.lang.Null <double>(((s.z * f.x) - (s.x * f.z)), true), new global::haxe.lang.Null <double>(((s.x * f.y) - (s.y * f.x)), true));
global::glm.Vec3 u = dest3;
{
dest._00 = ((double)(1));
dest._10 = ((double)(0));
dest._20 = ((double)(0));
dest._30 = ((double)(0));
dest._01 = ((double)(0));
dest._11 = ((double)(1));
dest._21 = ((double)(0));
dest._31 = ((double)(0));
dest._02 = ((double)(0));
dest._12 = ((double)(0));
dest._22 = ((double)(1));
dest._32 = ((double)(0));
dest._03 = ((double)(0));
dest._13 = ((double)(0));
dest._23 = ((double)(0));
dest._33 = ((double)(1));
}
dest._00 = s.x;
dest._10 = s.y;
dest._20 = s.z;
dest._01 = u.x;
dest._11 = u.y;
dest._21 = u.z;
dest._02 = -(f.x);
dest._12 = -(f.y);
dest._22 = -(f.z);
dest._30 = -(((((s.x * eye.x) + (s.y * eye.y)) + (s.z * eye.z))));
dest._31 = -(((((u.x * eye.x) + (u.y * eye.y)) + (u.z * eye.z))));
dest._32 = (((f.x * eye.x) + (f.y * eye.y)) + (f.z * eye.z));
return(dest);
}
}
public static double distance(global::glm.Vec3 a, global::glm.Vec3 b)
{
return(global::System.Math.Sqrt(((double)((((((a.x - b.x)) * ((a.x - b.x))) + (((a.y - b.y)) * ((a.y - b.y)))) + (((a.z - b.z)) * ((a.z - b.z))))))));
}
public static double distanceSquared(global::glm.Vec3 a, global::glm.Vec3 b)
{
return(((((a.x - b.x)) * ((a.x - b.x))) + (((a.y - b.y)) * ((a.y - b.y)))) + (((a.z - b.z)) * ((a.z - b.z))));
}
public static double dot(global::glm.Vec3 a, global::glm.Vec3 b)
{
return(((a.x * b.x) + (a.y * b.y)) + (a.z * b.z));
}
public static global::glm.Vec3 cross(global::glm.Vec2 a, global::glm.Vec2 b, global::glm.Vec3 dest)
{
dest = new global::glm.Vec3(new global::haxe.lang.Null <double>(((double)(0)), true), new global::haxe.lang.Null <double>(((double)(0)), true), new global::haxe.lang.Null <double>(((a.x * b.y) - (a.y * b.x)), true));
return(dest);
}
public bool @equals(global::glm.Vec3 b)
{
return(!(((((global::System.Math.Abs(((double)((this.x - b.x)))) >= global::glm.GLM.EPSILON) || (global::System.Math.Abs(((double)((this.y - b.y)))) >= global::glm.GLM.EPSILON)) || (global::System.Math.Abs(((double)((this.z - b.z)))) >= global::glm.GLM.EPSILON)))));
}
