Example #1
0
        public static SBSVector3 RandomDirection(SBSVector3 direction, float angle)
        {
            SBSVector3 d = direction.normalized;
            SBSVector3 t = SBSVector3.Cross(d + (SBSVector3)UnityEngine.Random.onUnitSphere, d).normalized;

            return(SBSQuaternion.AngleAxis(UnityEngine.Random.value * angle, t) * d);
        }
Example #2
0
        public static SBSMatrix4x4 TRS(SBSVector3 t, SBSQuaternion q, SBSVector3 s)
        {
            SBSMatrix4x4 r = new SBSMatrix4x4();

            float xy2 = 2.0f * q.x * q.y, xz2 = 2.0f * q.x * q.z, xw2 = 2.0f * q.x * q.w,
                  yz2 = 2.0f * q.y * q.z, yw2 = 2.0f * q.y * q.w, zw2 = 2.0f * q.z * q.w,
                  xx = q.x * q.x, yy = q.y * q.y, zz = q.z * q.z, ww = q.w * q.w,
                  sx = s.x, sy = s.y, sz = s.z;

            r.m00 = (xx - yy - zz + ww) * sx;
            r.m01 = (xy2 + zw2) * sx;
            r.m02 = (xz2 - yw2) * sx;
            r.m03 = 0.0f;
            r.m10 = (xy2 - zw2) * sy;
            r.m11 = (-xx + yy - zz + ww) * sy;
            r.m12 = (yz2 + xw2) * sy;
            r.m13 = 0.0f;
            r.m20 = (xz2 + yw2) * sz;
            r.m21 = (yz2 - xw2) * sz;
            r.m22 = (-xx - yy + zz + ww) * sz;
            r.m23 = 0.0f;
            r.m30 = t.x;
            r.m31 = t.y;
            r.m32 = t.z;
            r.m33 = 1.0f;

            return(r);
        }
Example #3
0
        public static SBSVector3 Lerp(SBSVector3 from, SBSVector3 to, float t)
        {
            t = Mathf.Clamp01(t);
            float s = 1.0f - t;

            return(new SBSVector3(from.x * s + to.x * t, from.y * s + to.y * t, from.z * s + to.z * t));
        }
Example #4
0
 public SBSAngleAxis(float _angle, SBSVector3 _axis)
 {
     angle  = _angle;
     axis.x = _axis.x;
     axis.y = _axis.y;
     axis.z = _axis.z;
 }
Example #5
0
    public void DrawGizmos(float trasversal, Color col)
    {
        int numSegments = (TokenType.Rect == type ? 1 : 10);//Math.Max(1, (int)(lengthOrRadius / 10.0f)));

        float l = 0.0f,
              s = 1.0f / (float)numSegments;

        Gizmos.color = col;

        for (int i = 0; i < numSegments; ++i)
        {
#if UNITY_FLASH
            SBSVector3 p0 = new SBSVector3(), t0 = new SBSVector3(), p1 = new SBSVector3(), t1 = new SBSVector3();

            this.TokenToWorld(l, trasversal, p0, t0);
            this.TokenToWorld(l + s, trasversal, p1, t1);
#else
            SBSVector3 p0, t0, p1, t1;

            this.TokenToWorld(l, trasversal, out p0, out t0);
            this.TokenToWorld(l + s, trasversal, out p1, out t1);
#endif

            Gizmos.DrawLine(p0, p1);
//          Gizmos.DrawRay(p0, t0);

            l += s;
        }
    }
Example #6
0
 public static SBSVector3 Cross(SBSVector3 v0, SBSVector3 v1)
 {
     return(new SBSVector3(
                v0.y * v1.z - v1.y * v0.z,
                v0.z * v1.x - v1.z * v0.x,
                v0.x * v1.y - v1.x * v0.y));
 }
Example #7
0
        public static float SqrDistance(SBSVector3 v0, SBSVector3 v1)
        {
            float dx = v1.x - v0.x;
            float dy = v1.y - v0.y;
            float dz = v1.z - v0.z;

            return(dx * dx + dy * dy + dz * dz);
        }
Example #8
0
        public void ProjectPoint(SBSVector3 p, SBSVector3 o)
        {
            float d = SBSVector3.Dot(normal, p) + distance;

            o.x = p.x - d * normal.x;
            o.y = p.y - d * normal.y;
            o.z = p.z - d * normal.z;
        }
Example #9
0
        public void ReflectVector(SBSVector3 v, SBSVector3 o)
        {
            float _2d = 2.0f * SBSVector3.Dot(normal, v);

            o.x = v.x - _2d * normal.x;
            o.y = v.y - _2d * normal.y;
            o.z = v.z - _2d * normal.z;
        }
Example #10
0
        public void ProjectVector(SBSVector3 v, SBSVector3 o)
        {
            float d = SBSVector3.Dot(normal, v);

            o.x = v.x - d * normal.x;
            o.y = v.y - d * normal.y;
            o.z = v.z - d * normal.z;
        }
Example #11
0
        public void ReflectPoint(SBSVector3 p, SBSVector3 o)
        {
            float _2d = 2.0f * (SBSVector3.Dot(normal, p) + distance);

            o.x = p.x - _2d * normal.x;
            o.y = p.y - _2d * normal.y;
            o.z = p.z - _2d * normal.z;
        }
Example #12
0
        public SBSVector3 MultiplyPoint3x4(SBSVector3 p)
        {
            float px = p.x, py = p.y, pz = p.z;

            return(new SBSVector3(
                       px * m00 + py * m10 + pz * m20 + m30,
                       px * m01 + py * m11 + pz * m21 + m31,
                       px * m02 + py * m12 + pz * m22 + m32));
        }
Example #13
0
        public void MultiplyPoint3x4(SBSVector3 p, out SBSVector3 o)
#endif
        {
            float px = p.x, py = p.y, pz = p.z;

            o.x = px * m00 + py * m10 + pz * m20 + m30;
            o.y = px * m01 + py * m11 + pz * m21 + m31;
            o.z = px * m02 + py * m12 + pz * m22 + m32;
        }
Example #14
0
        public SBSVector3 MultiplyVector(SBSVector3 v)
        {
            float vx = v.x, vy = v.y, vz = v.z;

            return(new SBSVector3(
                       vx * m00 + vy * m10 + vz * m20,
                       vx * m01 + vy * m11 + vz * m21,
                       vx * m02 + vy * m12 + vz * m22));
        }
Example #15
0
        public void MultiplyVector(SBSVector3 v, out SBSVector3 o)
#endif
        {
            float vx = v.x, vy = v.y, vz = v.z;

            o.x = vx * m00 + vy * m10 + vz * m20;
            o.y = vx * m01 + vy * m11 + vz * m21;
            o.z = vx * m02 + vy * m12 + vz * m22;
        }
Example #16
0
        public static SBSQuaternion AngleAxis(float angle, SBSVector3 axis)
        {
            angle *= (SBSMath.ToRadians * 0.5f);
            SBSVector3 a = axis.normalized;
            float      s = SBSMath.Sin(angle),
                       c = SBSMath.Cos(angle);

            return(new SBSQuaternion(a.x * s, a.y * s, a.z * s, c));
        }
Example #17
0
        public static float Distance(SBSVector3 v0, SBSVector3 v1)
        {
            float dx = v1.x - v0.x;
            float dy = v1.y - v0.y;
            float dz = v1.z - v0.z;
            float dd = dx * dx + dy * dy + dz * dz;

            return(SBSMath.Sqrt(dd));
        }
Example #18
0
        public SBSVector3 MultiplyPoint(SBSVector3 p)
        {
            float px = p.x, py = p.y, pz = p.z,
                  oow = 1.0f / (px * m03 + py * m13 + pz * m23 + m33);

            return(new SBSVector3(
                       (px * m00 + py * m10 + pz * m20 + m30) * oow,
                       (px * m01 + py * m11 + pz * m21 + m31) * oow,
                       (px * m02 + py * m12 + pz * m22 + m32) * oow));
        }
Example #19
0
        public void MultiplyPoint(SBSVector3 p, out SBSVector3 o)
#endif
        {
            float px = p.x, py = p.y, pz = p.z,
                  oow = 1.0f / (px * m03 + py * m13 + pz * m23 + m33);

            o.x = (px * m00 + py * m10 + pz * m20 + m30) * oow;
            o.y = (px * m01 + py * m11 + pz * m21 + m31) * oow;
            o.z = (px * m02 + py * m12 + pz * m22 + m32) * oow;
        }
Example #20
0
        public static SBSQuaternion Integrate(SBSQuaternion rotation, SBSVector3 angularVelocity, float dt)
        {
            SBSQuaternion spin = new SBSQuaternion(angularVelocity.x, angularVelocity.y, angularVelocity.z, 0.0f) * rotation;

            spin.ScaleBy(0.5f * dt);
            SBSQuaternion output = rotation + spin;

            output.Normalize();
            return(output);
        }
Example #21
0
        public void SetAngleAxis(float angle, SBSVector3 axis)
        {
            angle *= (SBSMath.ToRadians * 0.5f);
            SBSVector3 a = axis.normalized;
            float      s = SBSMath.Sin(angle),
                       c = SBSMath.Cos(angle);

            x = a.x * s;
            y = a.y * s;
            z = a.z * s;
            w = c;
        }
Example #22
0
        public void Rotate(SBSVector3 v, ref SBSVector3 o)
#endif
        {
            float w1 = -x * v.x - y * v.y - z * v.z;
            float x1 = w * v.x + y * v.z - z * v.y;
            float y1 = w * v.y - x * v.z + z * v.x;
            float z1 = w * v.z + x * v.y - y * v.x;

            o.x = -w1 * x + x1 * w - y1 * z + z1 * y;
            o.y = -w1 * y + x1 * z + y1 * w - z1 * x;
            o.z = -w1 * z - x1 * y + y1 * x + z1 * w;
        }
Example #23
0
        public SBSBounds(SBSVector3 center, SBSVector3 size)
        {
            float ex = size.x * 0.5f, ey = size.y * 0.5f, ez = size.z * 0.5f;

            min.x = center.x - ex;
            min.y = center.y - ey;
            min.z = center.z - ez;

            max.x = center.x + ex;
            max.y = center.y + ey;
            max.z = center.z + ez;
        }
Example #24
0
        public bool Intersect2D(SBSLine2D line, out SBSVector3 point)
        {
            float det = this.A * line.B - line.A * this.B;
            point = SBSVector3.zero;

            if (det == 0)
                return false;

            point.x = (line.B * this.C - this.B * line.C) / det;
            point.y = (this.A * line.C - line.A * this.C) / det;
            return true;
        }
Example #25
0
        public void Encapsulate(SBSVector3 p)
        {
            float px = p.x, py = p.y, pz = p.z;

            min.x = SBSMath.Min(min.x, px);
            min.y = SBSMath.Min(min.y, py);
            min.z = SBSMath.Min(min.z, pz);

            max.x = SBSMath.Max(max.x, px);
            max.y = SBSMath.Max(max.y, py);
            max.z = SBSMath.Max(max.z, pz);
        }
Example #26
0
    void Update()
    {
        foreach (Checkpoint checkpoint in checkpoints)
        {
            if (null == checkpoint || !checkpoint.enabled)
            {
                continue;
            }

            LevelObject   chkPtLvlObj = checkpoint.GetComponent <LevelObject>();
            LevelObject[] gameObjects = LevelRoot.Instance.Query(chkPtLvlObj.Bounds, checkpoint.layersMask);

            foreach (LevelObject levelObj in gameObjects)
            {
                if (!levelObj.IsMovable)
                {
                    continue;
                }

                SBSVector3 prevLocalPt = chkPtLvlObj.WorldToLocal.MultiplyPoint3x4(((MovableLevelObject)levelObj).PrevLocalToWorld.position);
                SBSVector3 localPt = chkPtLvlObj.WorldToLocal.MultiplyPoint3x4(levelObj.LocalToWorld.position);
                float      prevDist = 0.0f, dist = 0.0f;

                switch (checkpoint.type)
                {
                case Checkpoint.Type.Cylindrical:
                    prevLocalPt -= (SBSVector3)checkpoint.upVector * SBSVector3.Dot(checkpoint.upVector, prevLocalPt);
                    localPt     -= (SBSVector3)checkpoint.upVector * SBSVector3.Dot(checkpoint.upVector, localPt);
                    prevDist     = prevLocalPt.magnitude;
                    dist         = localPt.magnitude;
                    break;

                case Checkpoint.Type.Spherical:
                    prevDist = prevLocalPt.magnitude;
                    dist     = localPt.magnitude;
                    break;
                }

                if (prevDist > checkpoint.radius && dist <= checkpoint.radius)
                {
                    Debug.Log(levelObj.name + " has entered checkpoint " + checkpoint.name);
                    levelObj.SendMessage("OnCheckpointEnter", checkpoint, SendMessageOptions.DontRequireReceiver);
                }

                if (prevDist <= checkpoint.radius && dist > checkpoint.radius)
                {
                    Debug.Log(levelObj.name + " has exited checkpoint " + checkpoint.name);
                    levelObj.SendMessage("OnCheckpointExit", checkpoint, SendMessageOptions.DontRequireReceiver);
                }
            }
        }
    }
Example #27
0
 public SBSVector3[] GetVertices()
 {
     SBSVector3[] dest = new SBSVector3[8];
     dest[0] = new SBSVector3(min.x, min.y, min.z);
     dest[1] = new SBSVector3(max.x, min.y, min.z);
     dest[2] = new SBSVector3(max.x, max.y, min.z);
     dest[3] = new SBSVector3(min.x, max.y, min.z);
     dest[4] = new SBSVector3(min.x, min.y, max.z);
     dest[5] = new SBSVector3(max.x, min.y, max.z);
     dest[6] = new SBSVector3(max.x, min.y, max.z);
     dest[7] = new SBSVector3(min.x, min.y, max.z);
     return(dest);
 }
Example #28
0
        public static SBSVector3 Rotate(SBSVector3 from, SBSVector3 to, float t)
        {
            SBSVector3 a = SBSVector3.Cross(from, to);

            if (a.sqrMagnitude > 1.0e-3f)
            {
                return(SBSQuaternion.AngleAxis(SBSVector3.Angle(from, to) * t, a) * from);
            }
            else
            {
                return(to);
            }
        }
Example #29
0
        public static SBSMatrix4x4 LookAt(SBSVector3 eye, SBSVector3 target, SBSVector3 up)
        {
            SBSVector3 zAxis = target - eye;

            zAxis.Normalize();
            SBSVector3 xAxis = SBSVector3.Cross(up, zAxis);

            xAxis.Normalize();
            SBSVector3 yAxis = SBSVector3.Cross(zAxis, xAxis);

            return(new SBSMatrix4x4(
                       xAxis.x, xAxis.y, xAxis.z, 0.0f,
                       yAxis.x, yAxis.y, yAxis.z, 0.0f,
                       zAxis.x, zAxis.y, zAxis.z, 0.0f,
                       eye.x, eye.y, eye.z, 1.0f));
        }
Example #30
0
        public static SBSQuaternion LookRotation(SBSVector3 forward, SBSVector3 up)
        {
#if UNITY_FLASH
            forward = forward.normalized;
#else
            forward.Normalize();
#endif
            SBSVector3 right = SBSVector3.Cross(up.normalized, forward).normalized;
            up = SBSVector3.Cross(forward, right);

            float w    = SBSMath.Sqrt(1.0f + right.x + up.y + forward.z) * 0.5f,
                  oo4w = 1.0f / (4.0f * w),
                  x    = (forward.y - up.z) * oo4w,
                  y    = (right.z - forward.x) * oo4w,
                  z    = (up.x - right.y) * oo4w;

            return(new SBSQuaternion(x, y, z, w));
        }
Example #31
0
    void Update()
    {
        foreach (Checkline checkline in checklines)
        {
            if (null == checkline || !checkline.enabled)
            {
                continue;
            }

            LevelObject   chkLineObj  = checkline.GetComponent <LevelObject>();
            SBSVector3    linePos     = chkLineObj.LocalToWorld.position;
            LevelObject[] gameObjects = LevelRoot.Instance.Query(chkLineObj.Bounds, checkline.layersMask);

            foreach (LevelObject levelObj in gameObjects)
            {
                if (!levelObj.IsMovable)
                {
                    continue;
                }

                SBSVector3 levelObjPos = levelObj.LocalToWorld.position;
                SBSPlane   linePlane   = new SBSPlane(chkLineObj.LocalToWorld.MultiplyVector(checkline.perpendicularAxis), linePos);

                float d0 = linePlane.GetDistanceToPoint(((MovableLevelObject)levelObj).PrevLocalToWorld.position);
                float d1 = linePlane.GetDistanceToPoint(levelObjPos);

                bool front = d0 < 0.0f && d1 >= 0.0f,
                     back  = d0 >= 0.0f && d1 < 0.0f;
                if (front || back)
                {
                    SBSVector3 n = chkLineObj.LocalToWorld.MultiplyVector(checkline.parallelAxis);

                    SBSPlane p0 = new SBSPlane(n, linePos - n * (checkline.width * 0.5f)),
                             p1 = new SBSPlane(-n, linePos + n * (checkline.width * 0.5f));

                    if (p0.GetDistanceToPoint(levelObjPos) >= 0.0f && p1.GetDistanceToPoint(levelObjPos) >= 0.0f)
                    {
                        Debug.Log(levelObj.name + " has passed checkline " + checkline.name);
                        levelObj.SendMessage("OnCheckline", new Message(checkline, front), SendMessageOptions.DontRequireReceiver);
                    }
                }
            }
        }
    }
 public static bool LessAllXY(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x < v2.x && v1.y < v2.y;
 }
Example #33
0
        public SBSVector3 GetAttributeAsVector3(string name, SBSVector3 defaultValue)
        {
            string ret;
            if (attributes.TryGetValue(name, out ret))
            {
                char[] delimeters = { ',' };
                string[] parts = ret.Split(delimeters, StringSplitOptions.RemoveEmptyEntries);
                int c = parts.Length;

                float x = c > 0 ? float.Parse(parts[0]) : 0.0f,
                      y = c > 1 ? float.Parse(parts[1]) : 0.0f,
                      z = c > 2 ? float.Parse(parts[2]) : 0.0f;

                return new SBSVector3(x, y, z);
            }
            else
                return defaultValue;
        }
 public static bool GreaterAllXY(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x > v2.x && v1.y > v2.y;
 }
		public static float Dot(SBSVector3 v0, SBSVector3 v1)
        {
            return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z;
        }
		public void SetAngleAxis(float angle, SBSVector3 axis)
		{
			angle *= (SBSMath.ToRadians * 0.5f);
			SBSVector3 a = axis.normalized;
			float s = SBSMath.Sin(angle),
				  c = SBSMath.Cos(angle);
			x = a.x * s;
			y = a.y * s;
			z = a.z * s;
			w = c;
		}
        public static SBSQuaternion LookRotation(SBSVector3 forward, SBSVector3 up)
        {
#if UNITY_FLASH
            forward = forward.normalized;
#else
            forward.Normalize();
#endif
            SBSVector3 right = SBSVector3.Cross(up.normalized, forward).normalized;
            up = SBSVector3.Cross(forward, right);

            float w    = SBSMath.Sqrt(1.0f + right.x + up.y + forward.z) * 0.5f,
                  oo4w = 1.0f / (4.0f * w),
                  x    = (forward.y - up.z) * oo4w,
                  y    = (right.z - forward.x) * oo4w,
                  z    = (up.x - right.y) * oo4w;

            return new SBSQuaternion(x, y, z, w);
        }
 public static bool LessEqualAny(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x <= v2.x || v1.y <= v2.y || v1.z <= v2.z;
 }
		public void Rotate(SBSVector3 v, SBSVector3 o)
 public void DecrementBy(SBSVector3 v0)
 {
     x -= v0.x;
     y -= v0.y;
     z -= v0.z;
 }
 public static SBSVector3 Lerp(SBSVector3 from, SBSVector3 to, float t)
 {
     t = Mathf.Clamp01(t);
     float s = 1.0f - t;
     return new SBSVector3(from.x * s + to.x * t, from.y * s + to.y * t, from.z * s + to.z * t);
 }
 public void IncrementBy(SBSVector3 v0)
 {
     x += v0.x;
     y += v0.y;
     z += v0.z;
 }
        public void MultiplyVector(SBSVector3 v, out SBSVector3 o)
#endif
		{
			float vx = v.x, vy = v.y, vz = v.z;
			o.x = vx * m00 + vy * m10 + vz * m20;
			o.y = vx * m01 + vy * m11 + vz * m21;
			o.z = vx * m02 + vy * m12 + vz * m22;
		}
 public static SBSVector3 Rotate(SBSVector3 from, SBSVector3 to, float t)
 {
     SBSVector3 a = SBSVector3.Cross(from, to);
     if (a.sqrMagnitude > 1.0e-3f)
         return SBSQuaternion.AngleAxis(SBSVector3.Angle(from, to) * t, a) * from;
     else
         return to;
 }
 public static bool LessAll(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x < v2.x && v1.y < v2.y && v1.z < v2.z;
 }
    private bool ParseInitialModel(IJSonObject jsonObj)
    {
        Element el;
        SBSVector3 pos = new SBSVector3();
        bool result;

        try
        {
            if (null == jsonObj["initial_model"])
                return false;
        }
        catch (Exception ex)
        {
            return false;
        }

        for (int i = 0; i < jsonObj["initial_model"].Count; i++)
        {
            el = new Element();
            //NUMERATOR
            try
            {
                result = Int32.TryParse(jsonObj["initial_model"][i]["numerator"].ToString(), out el.numerator);
                if (!result)
                    el.numerator = 1;
                else
                    el.numerator = Mathf.Max(0, el.numerator);
            }
            catch (Exception ex)
            {
                el.numerator = 1;
            }

            //DENUMERATOR
            try
            {
                result = Int32.TryParse(jsonObj["initial_model"][i]["denominator"].ToString(), out el.denominator);
                if (!result)
                    el.denominator = 1;
                else
                    el.denominator = Mathf.Max(1, el.denominator);
            }
            catch (Exception ex)
            {
                el.denominator = 1;
            }

            //PARTTION
            try
            {
                result = Int32.TryParse(jsonObj["initial_model"][i]["partition"].ToString(), out el.partitions);
                //if (!result)
                    el.partitions = 1;
               // else
                  //  el.partitions = Mathf.Max(1, el.partitions);
            }
            catch (Exception ex)
            {
                el.partitions = 1;
            }
            el.partNumerator = el.numerator * el.partitions;
            el.partDenominator = el.denominator * el.partitions;

            if ((float)el.partNumerator / (float)el.partDenominator > Workspace.MAXVALUE)
            {
                el.partNumerator = el.partDenominator * Workspace.MAXVALUE;
                el.numerator = el.partDenominator / el.partitions;
            }

            el.state = ElementsState.Fraction;
            el.mode = InteractionMode.Moving;

            //TYPE
            try
            {
                el.type = (ElementsType)Enum.Parse(typeof(ElementsType), jsonObj["initial_model"][i]["type"].ToString());
            }
            catch (Exception ex)
            {
                el.type = ElementsType.HRect;
            }

            //POSITION
            try
            {
                result = float.TryParse(jsonObj["initial_model"][i]["position"]["x"].ToString(), out pos.x);

                if (!result)
                    pos.x = 0.0f;
                else
                    pos.x = Mathf.Clamp(pos.x, -8.0f, 8.0f);
                result = float.TryParse(jsonObj["initial_model"][i]["position"]["y"].ToString(), out pos.y);
                if (!result)
                    pos.y = 0.0f;
                else
                    pos.y = Mathf.Clamp(pos.y, -5.0f, 5.0f);
                /* result = float.TryParse(jsonObj["fractions"][i]["position"]["z"].ToString(), out pos.z);
                 if (!result)
                     pos.z = 0.0f;*/
                el.position = pos;
            }
            catch (Exception ex)
            {
                el.position = new SBSVector3(0.0f, 0.0f, 0.0f);
            }

            try
            {
                switch (jsonObj["initial_model"][i]["color"].ToString())
                {
                    case "yellow":
                        el.color = Workspace.Instance.colorList[1];
                        break;
                    case "blue":
                        el.color = Workspace.Instance.colorList[2];
                        break;
                    case "purple":
                        el.color = Workspace.Instance.colorList[3];
                        break;
                    case "red":
                        el.color = Workspace.Instance.colorList[0];
                        break;
                    default:
                        el.color = Workspace.Instance.colorList[0];
                        break;
                }
            }
            catch (Exception ex)
            {
                el.color = Workspace.Instance.colorList[0];
            }
            elements.Add(el);
            // Debug.Log("element i " + i +" "+ el);
        }
        return true;
    }
 public static SBSQuaternion LookRotation(SBSVector3 forward)
 {
     return LookRotation(forward, SBSVector3.up);
 }
Example #48
0
 public SBSLine2D(SBSVector3 p1, SBSVector3 p2)
 {
     A = p2.y - p1.y;
     B = p1.x - p2.x;
     C = A * p1.x + B * p1.y;
 }
        public void Rotate(SBSVector3 v, ref SBSVector3 o)
#endif
		{
			float w1 = -x * v.x - y * v.y - z * v.z;
			float x1 =  w * v.x + y * v.z - z * v.y;
			float y1 =  w * v.y - x * v.z + z * v.x;
			float z1 =  w * v.z + x * v.y - y * v.x;

			o.x = -w1 * x + x1 * w - y1 * z + z1 * y;
			o.y = -w1 * y + x1 * z + y1 * w - z1 * x;
			o.z = -w1 * z - x1 * y + y1 * x + z1 * w;
		}
 public static bool LessEqualAll(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x <= v2.x && v1.y <= v2.y && v1.z <= v2.z;
 }
		public static SBSQuaternion AngleAxis(float angle, SBSVector3 axis)
		{
			angle *= (SBSMath.ToRadians * 0.5f);
			SBSVector3 a = axis.normalized;
			float s = SBSMath.Sin(angle),
				  c = SBSMath.Cos(angle);
			return new SBSQuaternion(a.x * s, a.y * s, a.z * s, c);
		}
        public static SBSVector3 Cross(SBSVector3 v0, SBSVector3 v1)
        {
            return new SBSVector3(
				v0.y * v1.z - v1.y * v0.z,
				v0.z * v1.x - v1.z * v0.x,
				v0.x * v1.y - v1.x * v0.y);
        }
		public static float SqrDistance(SBSVector3 v0, SBSVector3 v1)
		{
			float dx = v1.x - v0.x;
			float dy = v1.y - v0.y;
			float dz = v1.z - v0.z;
			return dx * dx + dy * dy + dz * dz;
		}
 public static bool GreaterEqualAll(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x >= v2.x && v1.y >= v2.y && v1.z >= v2.z;
 }
        public static float Distance(SBSVector3 v0, SBSVector3 v1)
        {
			float dx = v1.x - v0.x;
			float dy = v1.y - v0.y;
			float dz = v1.z - v0.z;
			float dd = dx * dx + dy * dy + dz * dz;
            return SBSMath.Sqrt(dd);
        }
        public static float Angle(SBSVector3 v0, SBSVector3 v1)
        {
			return SBSMath.Acos(SBSVector3.Dot(v0.normalized, v1.normalized)) * SBSMath.ToDegrees;
        }
 public static bool GreaterEqualAny(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x >= v2.x || v1.y >= v2.y || v1.z >= v2.z;
 }
 public static SBSVector3 RandomDirection(SBSVector3 direction, float angle)
 {
     SBSVector3 d = direction.normalized;
     SBSVector3 t = SBSVector3.Cross(d + (SBSVector3)UnityEngine.Random.onUnitSphere, d).normalized;
     return SBSQuaternion.AngleAxis(UnityEngine.Random.value * angle, t) * d;
 }
 public static bool LessAny(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x < v2.x || v1.y < v2.y || v1.z < v2.z;
 }
 public static bool GreaterAny(SBSVector3 v1, SBSVector3 v2)
 {
     return v1.x > v2.x || v1.y > v2.y || v1.z > v2.z;
 }