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 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); }
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 SBSAngleAxis(float _angle, SBSVector3 _axis) { angle = _angle; axis.x = _axis.x; axis.y = _axis.y; axis.z = _axis.z; }
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; } }
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 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; }
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; }
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; }
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; }
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)); }
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; }
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)); }
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 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 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 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)); }
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; }
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); }
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 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 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; }
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; }
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); }
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); } } } }
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); }
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 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)); }
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)); }
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; }
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 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 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); }
public SBSLine2D(SBSVector3 p1, SBSVector3 p2) { A = p2.y - p1.y; B = p1.x - p2.x; C = A * p1.x + B * p1.y; }
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; }