/* Main source code (CableSim.hx) import haxe.Timer; import pot.graphics.Graphics; import muun.la.Quat; import muun.la.Mat3; import muun.la.Vec3; import js.Browser; import pot.core.App; inline final INTERVAL:Float = 0.2; inline final RADIUS:Float = 0.3; inline final GRAVITY:Float = 0.00075 * 1; function rand(from:Float, to:Float):Float { return Math.random() * (to - from) + from; } inline function abs(x:Float):Float { return x < 0 ? -x : x; } class Vertex { public final p:Vec3; public final lv:Vec3; public final av:Vec3; public final r:Mat3; public final q:Quat; public var invM:Float; public var invI:Float; public function new(p:Vec3, fixedL:Bool = false, fixedA:Bool = false) { this.p = p; lv = fixedL ? Vec3.zero() : new Vec3(rand(-1, 1), rand(-1, 1), rand(-1, 1)) * 1e-3; av = Vec3.zero(); r = Mat3.identity(); q = Quat.identity(); invM = fixedL ? 0 : 1; invI = fixedA ? 0 : 1 / (1 / 3 * RADIUS * RADIUS); } public function update():Void { p += lv; var angle = av.length(); if (angle > 0) { var dq = Quat.rotation(angle, av.normalized()); q.copyFrom(dq.mulQuat(q)); } r.copyFrom(q.toMat3()); if (invM > 0) lv.y -= GRAVITY; } public inline function nextRelative(local:Vec3):Vec3 { return nextQuat().mulVec(local); } public inline function nextQuat():Quat { return Quat.rotation(av.length(), av.normalized()).mulQuat(q); } public inline function applyImpulse(rel:Vec3, impulse:Vec3):Void { lv += invM * impulse; av += invI * rel.cross(impulse); } public function draw(g:Graphics):Void { g.pushMatrix(); g.transform(r.e00, r.e01, r.e02, p.x, r.e10, r.e11, r.e12, p.y, r.e20, r.e21, r.e22, p.z, 0, 0, 0, 1); g.box(INTERVAL, INTERVAL, INTERVAL); g.popMatrix(); } } class Spring { public final v1:Vertex; public final v2:Vertex; // local frames public final ex1:Vec3; public final ey1:Vec3; public final ez1:Vec3; public final ex2:Vec3; public final ey2:Vec3; public final ez2:Vec3; public final lp1:Vec3; // local public final lp2:Vec3; public final rp1:Vec3; // relative public final rp2:Vec3; public final p1:Vec3; // global public final p2:Vec3; public final effectiveMass:Mat3; public final angTwistImp:Vec3; public final angBendImp:Vec3; public final imp:Vec3; public function new(v1:Vertex, v2:Vertex, p:Vec3) { this.v1 = v1; this.v2 = v2; rp1 = p - v1.p; rp2 = p - v2.p; lp1 = v1.r.t().mulVec(rp1); lp2 = v2.r.t().mulVec(rp2); ex1 = lp1.normalized(); var tmp = abs(ex1.x) < abs(ex1.y) ? Vec3.ex() : Vec3.ey(); ey1 = tmp.cross(ex1).normalized(); ez1 = ex1.cross(ey1); ex2 = -lp2.normalized(); var tmpM = Quat.arc(ex1, ex2).toMat3(); ey2 = tmpM.mulVec(ey1); ez2 = tmpM.mulVec(ez1); p1 = p.copy(); p2 = p.copy(); effectiveMass = Mat3.zero(); angTwistImp = Vec3.zero(); angBendImp = Vec3.zero(); imp = Vec3.zero(); } public function preSolve():Void { rp1.copyFrom(v1.r.mulVec(lp1)); rp2.copyFrom(v2.r.mulVec(lp2)); effectiveMass.setZero(); effectiveMass += (v1.invM + v2.invM) * Mat3.identity(); var cross1 = rp1.crossMat(); var cross2 = rp2.crossMat(); effectiveMass += v1.invI * (cross1.t().mulMat(cross1)); effectiveMass += v2.invI * (cross2.t().mulMat(cross2)); effectiveMass.invEq(); imp.setZero(); angTwistImp.setZero(); angBendImp.setZero(); } public function solve():Void { var nrp1 = v1.nextRelative(lp1); var nrp2 = v2.nextRelative(lp2); p1.copyFrom(v1.p + v1.lv + nrp1); p2.copyFrom(v2.p + v2.lv + nrp2); var diff = p2 - p1; var gamma = 1; var impulse = gamma * effectiveMass.mulVec(diff); imp += impulse; v1.applyImpulse(nrp1, impulse); v2.applyImpulse(nrp2, -impulse); var q1 = v1.nextQuat(); var q2 = v2.nextQuat(); var r1 = q1.toMat3(); var r2 = q2.toMat3(); var relEx1 = r1.mulVec(ex1); var relEx2 = r2.mulVec(ex2); var relArcQ = Quat.arc(relEx1, relEx2); var relArcM = relArcQ.toMat3(); var relEy1On2 = relArcM.mulVec(r1.mulVec(ey1)); var relEy2 = r2.mulVec(ey2); var relEz2 = r2.mulVec(ez2); var x = relEy1On2.dot(relEy2); var y = relEy1On2.dot(relEz2); var angleTwist = -Math.atan2(y, x); var axisTwist = (relEx1 + relEx2).normalized(); var angleBend = Math.acos(relArcQ.w > 1 ? 1 : relArcQ.w < -1 ? -1 : relArcQ.w) * 2; var axisBend = relArcQ.getVec().normalized(); var cfmScale = 0.05; var cfmTwist = (v1.invI + v2.invI) * cfmScale * 1; var cfmBend = (v1.invI + v2.invI) * cfmScale * 3; var angTwistImpulse = 1 / (v1.invI + v2.invI + cfmTwist) * (angleTwist * axisTwist - cfmTwist * angTwistImp); var angBendImpulse = 1 / (v1.invI + v2.invI + cfmBend) * (angleBend * axisBend - cfmBend * angBendImp); v1.av += (angTwistImpulse + angBendImpulse) * v1.invI; v2.av -= (angTwistImpulse + angBendImpulse) * v2.invI; angTwistImp += angTwistImpulse; angBendImp += angBendImpulse; } } class Contact { public final v1:Vertex; public final v2:Vertex; public final imp:Vec3; public function new(v1:Vertex, v2:Vertex) { this.v1 = v1; this.v2 = v2; imp = Vec3.zero(); } public function solve():Void { var p1 = v1.p + v1.lv; var p2 = v2.p + v2.lv; var diff = p2 - p1; var dist = diff.length(); var newImp = Vec3.zero(); if (dist < RADIUS * 2) { var n = diff.normalized(); var overlap = RADIUS * 2 - dist; var effectiveMass = 1 / (v1.invM + v2.invM); newImp = -n * overlap * effectiveMass; v1.lv += newImp * v1.invM; v2.lv -= newImp * v2.invM; } } } class World { public var vs:Array; public var ss:Array; public var cs:Array; public var cables:Array; public function new() { vs = []; ss = []; cs = []; cables = []; } public function addCable(vs:Array):Void { cables.push(new Cable(vs)); } public function update():Void { var st = Timer.stamp(); cs.resize(0); var n = vs.length; var shift = Math.round(2 * RADIUS / INTERVAL) + 1; for (i in 0...n) { for (j in i + shift...n) { var v1 = vs[i]; var v2 = vs[j]; if (v1.invM == 0 && v2.invM == 0) continue; if ((v1.p - v2.p).length() < RADIUS * 2.5) { cs.push(new Contact(v1, v2)); } } } for (s in ss) s.preSolve(); var ss2 = ss.copy(); for (t in 0...20) { for (i in 1...ss2.length) { var j = Std.random(i + 1); var tmp = ss2[i]; ss2[i] = ss2[j]; ss2[j] = tmp; } for (s in ss2) s.solve(); for (c in cs) { c.solve(); } } for (v in vs) v.update(); var en = Timer.stamp(); // trace("solver: " + (en - st) * 1000 + "ms"); } public function draw(g:Graphics):Void { // for (v in vs) // v.draw(g); for (c in cables) c.draw(g); } } class Cable { public var vs:Array; public function new(vs:Array) { this.vs = vs; } // given in zig-zag order inline function quad(g:Graphics, v1:Vec3, v2:Vec3, v3:Vec3, v4:Vec3, n1:Vec3, n2:Vec3):Void { g.normal(n1.x, n1.y, n1.z); g.vertex(v1.x, v1.y, v1.z); g.normal(n2.x, n2.y, n2.z); g.vertex(v3.x, v3.y, v3.z); g.normal(n1.x, n1.y, n1.z); g.vertex(v2.x, v2.y, v2.z); g.normal(n2.x, n2.y, n2.z); g.vertex(v4.x, v4.y, v4.z); g.normal(n1.x, n1.y, n1.z); g.vertex(v2.x, v2.y, v2.z); g.normal(n2.x, n2.y, n2.z); g.vertex(v3.x, v3.y, v3.z); } inline function interp(v1:Vertex, v2:Vertex, t1:Vec3, t2:Vec3, t:Float, outP:Vec3, outR:Mat3):Void { var p1 = v1.p; var p2 = v2.p; outP.copyFrom((2 * t * t * t - 3 * t * t + 1) * p1 + (t * t * t - 2 * t * t + t) * t1 + (-2 * t * t * t + 3 * t * t) * p2 + (t * t * t - t * t) * t2); var q1 = v1.q; var q2 = v2.q; var dot = v1.q.dot(v2.q); if (dot < 0) { q2 = -q2; dot = -dot; } if (dot >= 1) { outR.copyFrom(v1.r); } else { var ang = Math.acos(dot); var sin = Math.sin(ang); if (sin <= 0) { outR.copyFrom(v1.r); } else { var coeff1 = Math.sin((1 - t) * ang) / sin; var coeff2 = Math.sin(t * ang) / sin; outR.copyFrom((q1 * coeff1 + q2 * coeff2).toMat3()); } } } public function draw(g:Graphics):Void { g.beginShape(Triangles); var n = vs.length; // basis final pe1 = Vec3.zero(); final pe2 = Vec3.zero(); final pe3 = Vec3.zero(); // vertex final pv1 = Vec3.zero(); final pv2 = Vec3.zero(); final pv3 = Vec3.zero(); final pv4 = Vec3.zero(); var first = true; var radius = RADIUS / Math.sqrt(2); for (i in 1...n) { var v1 = vs[i - 1]; var v2 = vs[i]; final t1 = i == 1 ? Vec3.zero() : v1.p - vs[i - 2].p; final t2 = i == n - 1 ? Vec3.zero() : vs[i + 1].p - v2.p; t1 *= 0.5; t2 *= 0.5; for (t in (i == n - 1 ? [0, 0.25, 0.5, 0.75, 1] : [0, 0.25, 0.5, 0.75])) { final p = Vec3.zero(); final r = Mat3.zero(); interp(v1, v2, t1, t2, t, p, r); // basis final ne1 = r.mulVec(Vec3.ex()); final ne2 = r.mulVec(Vec3.ez()); final ne3 = r.mulVec(Vec3.ey()); // vertex final nv1 = p + (-ne1 - ne2) * radius; final nv2 = p + (-ne1 + ne2) * radius; final nv3 = p + (ne1 + ne2) * radius; final nv4 = p + (ne1 - ne2) * radius; if (first) { first = false; quad(g, nv2, nv1, nv3, nv4, ne3, ne3); } else { quad(g, pv1, pv2, nv1, nv2, -pe1, -ne1); quad(g, pv2, pv3, nv2, nv3, pe2, ne2); quad(g, pv3, pv4, nv3, nv4, pe1, ne1); quad(g, pv4, pv1, nv4, nv1, -pe2, -ne2); } pv1.copyFrom(nv1); pv2.copyFrom(nv2); pv3.copyFrom(nv3); pv4.copyFrom(nv4); pe1.copyFrom(ne1); pe2.copyFrom(ne2); pe3.copyFrom(ne3); } } quad(g, pv1, pv2, pv4, pv3, -pe3, -pe3); g.endShape(); } } class CableSim extends App { var g:Graphics; var w:World; var twist:Bool; var rotating:Vertex; var moving:Vertex; var idleCount:Int; final target:Vec3 = Vec3.zero(); override function setup():Void { pot.resize(Browser.window.innerWidth, Browser.window.innerHeight, cast Browser.window.devicePixelRatio); pot.frameRate(Auto); Browser.window.addEventListener("resize", () -> { pot.resize(Browser.window.innerWidth, Browser.window.innerHeight, cast Browser.window.devicePixelRatio); g.screen(canvas.width, canvas.height); }); Browser.window.setTimeout(pot.start, 500); g = new Graphics(canvas); g.init3D(); idleCount = 0; initScene(); } function createCable(initPos:Vec3, dir:Vec3, n:Int):Array { var vs = []; for (i in 0...n) { var v = new Vertex(initPos + INTERVAL * dir * i, i == 0, i == 0); v.q.copyFrom(Quat.arc(-Vec3.ey(), dir)); v.r.copyFrom(v.q.toMat3()); vs.push(v); } for (i in 1...n) { var v1 = vs[i - 1]; var v2 = vs[i]; w.ss.push(new Spring(v1, v2, (v1.p + v2.p) * 0.5)); } for (v in vs) w.vs.push(v); w.cables.push(new Cable(vs)); return vs; } function initScene():Void { w = new World(); var n = 30; var first = null; var last = null; for (i in -3...3 + 1) { for (j in -0...0 + 1) { var vs = createCable(new Vec3(i * 0.7, 2.5, j * 0.7), -Vec3.ey(), n); if (i == 0 && j == 0) { first = vs[0]; last = vs[vs.length - 1]; } } } twist = true; { // first.q.setRotation(-Math.PI * 0.4, Vec3.ez()); // last.q.setRotation(Math.PI * 0.4, Vec3.ez()); rotating = first; moving = last; } } override function loop():Void { if (twist) { // rotating.av.copyFrom(rotating.q.mulVec(Vec3.ey() * Math.sin(frameCount * 0.01) * 0.35)); // rotating.av.copyFrom(rotating.q.mulVec(Vec3.ey() * 0.05)); } var touching = input.touches.length > 0; var clicking = input.mouse.left; var screenX; var screenY; var camera = new Vec3(2, 3, 7); var screenScale = Math.min(1, canvas.width / canvas.height); var halfScreenHeight = Math.tan(30 * Math.PI / 180); var halfScreenWidth = halfScreenHeight * canvas.width / canvas.height; if (touching || clicking) { idleCount = 0; var mx = touching ? input.touches[0].x : input.mouse.x; var my = touching ? input.touches[0].y : input.mouse.y; screenX = mx / canvas.width * 2 - 1; screenY = 1 - my / canvas.height * 2; var ez = camera.normalized(); var ex = Vec3.ey().cross(ez).normalized(); var ey = ez.cross(ex); var dir = new Vec3(screenX * halfScreenWidth, screenY * halfScreenHeight, -1).normalized(); dir = dir.x * ex + dir.y * ey + dir.z * ez; var dist = camera.length(); target.copyFrom((camera + dir * dist) / screenScale); moving.p += (target - moving.p) * 0.3; moving.lv += (target - moving.p) * 0.2; } if (++idleCount > 120) { clicking = true; var ang = (idleCount - 120) * 0.02; target.copyFrom(new Vec3(Math.sin(ang) * 4, -2, Math.sin(2 * ang) * 2)); moving.p += (target - moving.p) * 0.2; moving.lv += (target - moving.p) * 0.1; } w.update(); g.camera(camera.x, camera.y, camera.z, 0, 0, 0, 0, 1, 0); g.inScene(() -> { g.clear(0.3, 0.3, 0.3); g.lights(); g.color(1, 1, 1); g.shininess(8); g.specular(1); g.diffuse(1); g.scale(screenScale, screenScale, screenScale); w.draw(g); // shadow g.pushMatrix(); g.translate(0, -4, 0); g.scale(1, 0, 1); g.specular(0); g.diffuse(0); g.emission(1); g.color(0.1, 0.1, 0.1); w.draw(g); g.popMatrix(); if (clicking || touching) { g.pushMatrix(); var from = moving.p; var to = target; var mid = (from + to) * 0.5; var rot = Quat.arc(Vec3.ex(), (to - from).normalized()).toMat3(); g.transform(rot.e00, rot.e01, rot.e02, mid.x, rot.e10, rot.e11, rot.e12, mid.y, rot.e20, rot.e21, rot.e22, mid.z, 0, 0, 0, 1); g.emission(1); g.diffuse(0); g.specular(0); g.color(1, 0.0, 0.0); g.box((to - from).length(), 0.1, 0.1); g.popMatrix(); } }); } static function main() { new CableSim(cast Browser.document.getElementById("canvas")); } } */ // Generated by Haxe 4.2.0 (function ($global) { "use strict"; class Vertex { constructor(p,fixedL,fixedA) { if(fixedA == null) { fixedA = false; } if(fixedL == null) { fixedL = false; } this.p = p; this.lv = fixedL ? new muun_la__$Vec3_Vec3Data(0,0,0) : new muun_la__$Vec3_Vec3Data(CableSim_rand(-1,1) * 1e-3,CableSim_rand(-1,1) * 1e-3,CableSim_rand(-1,1) * 1e-3); this.av = new muun_la__$Vec3_Vec3Data(0,0,0); this.r = new muun_la__$Mat3_Mat3Data(1,0,0,0,1,0,0,0,1); this.q = new muun_la__$Quat_QuatData(0,0,0,1); this.invM = fixedL ? 0 : 1; this.invI = fixedA ? 0 : 33.333333333333336; } update() { let a = this.p; let b = this.lv; a.x = a.x + b.x; a.y = a.y + b.y; a.z = a.z + b.z; let this1 = this.av; let angle = Math.sqrt(this1.x * this1.x + this1.y * this1.y + this1.z * this1.z); if(angle > 0) { let this1 = this.av; let l = Math.sqrt(this1.x * this1.x + this1.y * this1.y + this1.z * this1.z); if(l > 0) { l = 1 / l; } let sinHalfAngle = Math.sin(angle * 0.5); let cosHalfAngle = Math.cos(angle * 0.5); let x = this1.x * l * sinHalfAngle; let y = this1.y * l * sinHalfAngle; let z = this1.z * l * sinHalfAngle; let this2 = this.q; let b = this.q; let y1 = cosHalfAngle * b.y - x * b.z + y * b.w + z * b.x; let z1 = cosHalfAngle * b.z + x * b.y - y * b.x + z * b.w; let w = cosHalfAngle * b.w - x * b.x - y * b.y - z * b.z; this2.x = cosHalfAngle * b.x + x * b.w + y * b.z - z * b.y; this2.y = y1; this2.z = z1; this2.w = w; } let this2 = this.r; let this3 = this.q; let x2 = this3.x * 2; let y2 = this3.y * 2; let z2 = this3.z * 2; let xx = this3.x * x2; let yy = this3.y * y2; let zz = this3.z * z2; let xy = this3.x * y2; let yz = this3.y * z2; let xz = this3.x * z2; let wx = this3.w * x2; let wy = this3.w * y2; let wz = this3.w * z2; this2.e00 = 1 - yy - zz; this2.e01 = xy - wz; this2.e02 = xz + wy; this2.e10 = xy + wz; this2.e11 = 1 - xx - zz; this2.e12 = yz - wx; this2.e20 = xz - wy; this2.e21 = yz + wx; this2.e22 = 1 - xx - yy; if(this.invM > 0) { this.lv.y -= 0.00075; } } } Vertex.__name__ = true; class Spring { constructor(v1,v2,p) { this.v1 = v1; this.v2 = v2; let b = v1.p; this.rp1 = new muun_la__$Vec3_Vec3Data(p.x - b.x,p.y - b.y,p.z - b.z); let b1 = v2.p; this.rp2 = new muun_la__$Vec3_Vec3Data(p.x - b1.x,p.y - b1.y,p.z - b1.z); let this1 = v1.r; let b2 = this.rp1; this.lp1 = new muun_la__$Vec3_Vec3Data(this1.e00 * b2.x + this1.e10 * b2.y + this1.e20 * b2.z,this1.e01 * b2.x + this1.e11 * b2.y + this1.e21 * b2.z,this1.e02 * b2.x + this1.e12 * b2.y + this1.e22 * b2.z); let this2 = v2.r; let b3 = this.rp2; this.lp2 = new muun_la__$Vec3_Vec3Data(this2.e00 * b3.x + this2.e10 * b3.y + this2.e20 * b3.z,this2.e01 * b3.x + this2.e11 * b3.y + this2.e21 * b3.z,this2.e02 * b3.x + this2.e12 * b3.y + this2.e22 * b3.z); let this3 = this.lp1; let l = Math.sqrt(this3.x * this3.x + this3.y * this3.y + this3.z * this3.z); if(l > 0) { l = 1 / l; } this.ex1 = new muun_la__$Vec3_Vec3Data(this3.x * l,this3.y * l,this3.z * l); let x = this.ex1.x; let x1 = this.ex1.y; let b4 = this.ex1; let a = (x < 0 ? -x : x) < (x1 < 0 ? -x1 : x1) ? new muun_la__$Vec3_Vec3Data(1,0,0) : new muun_la__$Vec3_Vec3Data(0,1,0); let x2 = a.y * b4.z - a.z * b4.y; let y = a.z * b4.x - a.x * b4.z; let z = a.x * b4.y - a.y * b4.x; let l1 = Math.sqrt(x2 * x2 + y * y + z * z); if(l1 > 0) { l1 = 1 / l1; } this.ey1 = new muun_la__$Vec3_Vec3Data(x2 * l1,y * l1,z * l1); let this4 = this.ex1; let b5 = this.ey1; this.ez1 = new muun_la__$Vec3_Vec3Data(this4.y * b5.z - this4.z * b5.y,this4.z * b5.x - this4.x * b5.z,this4.x * b5.y - this4.y * b5.x); let this5 = this.lp2; let l2 = Math.sqrt(this5.x * this5.x + this5.y * this5.y + this5.z * this5.z); if(l2 > 0) { l2 = 1 / l2; } this.ex2 = new muun_la__$Vec3_Vec3Data(-(this5.x * l2),-(this5.y * l2),-(this5.z * l2)); let v11 = this.ex1; let v21 = this.ex2; let a1 = v11; let w = Math.sqrt((1 + (a1.x * v21.x + a1.y * v21.y + a1.z * v21.z)) * 0.5); let v; if(w == 0) { let x = v11.x * v11.x; let y = v11.y * v11.y; let z = v11.z * v11.z; let t3 = new muun_la__$Vec3_Vec3Data(0,0,1); let perp = x < y ? x < z ? new muun_la__$Vec3_Vec3Data(1,0,0) : t3 : y < z ? new muun_la__$Vec3_Vec3Data(0,1,0) : t3; let a = v11; let x1 = a.y * perp.z - a.z * perp.y; let y1 = a.z * perp.x - a.x * perp.z; let z1 = a.x * perp.y - a.y * perp.x; let l = Math.sqrt(x1 * x1 + y1 * y1 + z1 * z1); if(l > 0) { l = 1 / l; } v = new muun_la__$Vec3_Vec3Data(x1 * l,y1 * l,z1 * l); } else { let a = v11; v = new muun_la__$Vec3_Vec3Data((a.y * v21.z - a.z * v21.y) * 0.5 / w,(a.z * v21.x - a.x * v21.z) * 0.5 / w,(a.x * v21.y - a.y * v21.x) * 0.5 / w); } let x3 = v.x; let y1 = v.y; let z1 = v.z; let x21 = x3 * 2; let y2 = y1 * 2; let z2 = z1 * 2; let xx = x3 * x21; let yy = y1 * y2; let zz = z1 * z2; let xy = x3 * y2; let yz = y1 * z2; let xz = x3 * z2; let wx = w * x21; let wy = w * y2; let wz = w * z2; let a_e00 = 1 - yy - zz; let a_e01 = xy - wz; let a_e02 = xz + wy; let a_e10 = xy + wz; let a_e11 = 1 - xx - zz; let a_e12 = yz - wx; let a_e20 = xz - wy; let a_e21 = yz + wx; let a_e22 = 1 - xx - yy; let b6 = this.ey1; this.ey2 = new muun_la__$Vec3_Vec3Data(a_e00 * b6.x + a_e01 * b6.y + a_e02 * b6.z,a_e10 * b6.x + a_e11 * b6.y + a_e12 * b6.z,a_e20 * b6.x + a_e21 * b6.y + a_e22 * b6.z); let b7 = this.ez1; this.ez2 = new muun_la__$Vec3_Vec3Data(a_e00 * b7.x + a_e01 * b7.y + a_e02 * b7.z,a_e10 * b7.x + a_e11 * b7.y + a_e12 * b7.z,a_e20 * b7.x + a_e21 * b7.y + a_e22 * b7.z); this.p1 = new muun_la__$Vec3_Vec3Data(p.x,p.y,p.z); this.p2 = new muun_la__$Vec3_Vec3Data(p.x,p.y,p.z); this.effectiveMass = new muun_la__$Mat3_Mat3Data(0,0,0,0,0,0,0,0,0); this.angTwistImp = new muun_la__$Vec3_Vec3Data(0,0,0); this.angBendImp = new muun_la__$Vec3_Vec3Data(0,0,0); this.imp = new muun_la__$Vec3_Vec3Data(0,0,0); } preSolve() { let this1 = this.rp1; let this2 = this.v1.r; let b = this.lp1; let y = this2.e10 * b.x + this2.e11 * b.y + this2.e12 * b.z; let z = this2.e20 * b.x + this2.e21 * b.y + this2.e22 * b.z; this1.x = this2.e00 * b.x + this2.e01 * b.y + this2.e02 * b.z; this1.y = y; this1.z = z; let this3 = this.rp2; let this4 = this.v2.r; let b1 = this.lp2; let y1 = this4.e10 * b1.x + this4.e11 * b1.y + this4.e12 * b1.z; let z1 = this4.e20 * b1.x + this4.e21 * b1.y + this4.e22 * b1.z; this3.x = this4.e00 * b1.x + this4.e01 * b1.y + this4.e02 * b1.z; this3.y = y1; this3.z = z1; let this5 = this.effectiveMass; this5.e00 = 0; this5.e01 = 0; this5.e02 = 0; this5.e10 = 0; this5.e11 = 0; this5.e12 = 0; this5.e20 = 0; this5.e21 = 0; this5.e22 = 0; let a = this.effectiveMass; let lhs = this.v1.invM + this.v2.invM; a.e00 = a.e00 + 1 * lhs; a.e01 = a.e01 + 0 * lhs; a.e02 = a.e02 + 0 * lhs; a.e10 = a.e10 + 0 * lhs; a.e11 = a.e11 + 1 * lhs; a.e12 = a.e12 + 0 * lhs; a.e20 = a.e20 + 0 * lhs; a.e21 = a.e21 + 0 * lhs; a.e22 = a.e22 + 1 * lhs; let this6 = this.rp1; let e01 = -this6.z; let e02 = this6.y; let e10 = this6.z; let e12 = -this6.x; let e20 = -this6.y; let e21 = this6.x; let a_e00 = 0; let a_e11 = 0; let a_e22 = 0; let this7 = this.rp2; let e011 = -this7.z; let e021 = this7.y; let e101 = this7.z; let e121 = -this7.x; let e201 = -this7.y; let e211 = this7.x; let a_e001 = 0; let a_e111 = 0; let a_e221 = 0; let a1 = this.effectiveMass; let lhs1 = this.v1.invI; a1.e00 = a1.e00 + (a_e00 * a_e00 + e10 * e10 + e20 * e20) * lhs1; a1.e01 = a1.e01 + (a_e00 * e01 + e10 * a_e11 + e20 * e21) * lhs1; a1.e02 = a1.e02 + (a_e00 * e02 + e10 * e12 + e20 * a_e22) * lhs1; a1.e10 = a1.e10 + (e01 * a_e00 + a_e11 * e10 + e21 * e20) * lhs1; a1.e11 = a1.e11 + (e01 * e01 + a_e11 * a_e11 + e21 * e21) * lhs1; a1.e12 = a1.e12 + (e01 * e02 + a_e11 * e12 + e21 * a_e22) * lhs1; a1.e20 = a1.e20 + (e02 * a_e00 + e12 * e10 + a_e22 * e20) * lhs1; a1.e21 = a1.e21 + (e02 * e01 + e12 * a_e11 + a_e22 * e21) * lhs1; a1.e22 = a1.e22 + (e02 * e02 + e12 * e12 + a_e22 * a_e22) * lhs1; let a2 = this.effectiveMass; let lhs2 = this.v2.invI; a2.e00 = a2.e00 + (a_e001 * a_e001 + e101 * e101 + e201 * e201) * lhs2; a2.e01 = a2.e01 + (a_e001 * e011 + e101 * a_e111 + e201 * e211) * lhs2; a2.e02 = a2.e02 + (a_e001 * e021 + e101 * e121 + e201 * a_e221) * lhs2; a2.e10 = a2.e10 + (e011 * a_e001 + a_e111 * e101 + e211 * e201) * lhs2; a2.e11 = a2.e11 + (e011 * e011 + a_e111 * a_e111 + e211 * e211) * lhs2; a2.e12 = a2.e12 + (e011 * e021 + a_e111 * e121 + e211 * a_e221) * lhs2; a2.e20 = a2.e20 + (e021 * a_e001 + e121 * e101 + a_e221 * e201) * lhs2; a2.e21 = a2.e21 + (e021 * e011 + e121 * a_e111 + a_e221 * e211) * lhs2; a2.e22 = a2.e22 + (e021 * e021 + e121 * e121 + a_e221 * a_e221) * lhs2; let this8 = this.effectiveMass; let d00 = this8.e11 * this8.e22 - this8.e12 * this8.e21; let d01 = this8.e10 * this8.e22 - this8.e12 * this8.e20; let d02 = this8.e10 * this8.e21 - this8.e11 * this8.e20; let idet = this8.e00 * d00 - this8.e01 * d01 + this8.e02 * d02; if(idet != 0) { idet = 1 / idet; } let m_e02 = (this8.e01 * this8.e12 - this8.e02 * this8.e11) * idet; let m_e11 = (this8.e00 * this8.e22 - this8.e02 * this8.e20) * idet; let m_e12 = -(this8.e00 * this8.e12 - this8.e02 * this8.e10) * idet; let m_e21 = -(this8.e00 * this8.e21 - this8.e01 * this8.e20) * idet; let m_e22 = (this8.e00 * this8.e11 - this8.e01 * this8.e10) * idet; this8.e00 = d00 * idet; this8.e01 = -(this8.e01 * this8.e22 - this8.e02 * this8.e21) * idet; this8.e02 = m_e02; this8.e10 = -d01 * idet; this8.e11 = m_e11; this8.e12 = m_e12; this8.e20 = d02 * idet; this8.e21 = m_e21; this8.e22 = m_e22; let this9 = this.imp; this9.x = 0; this9.y = 0; this9.z = 0; let this10 = this.angTwistImp; this10.x = 0; this10.y = 0; this10.z = 0; let this11 = this.angBendImp; this11.x = 0; this11.y = 0; this11.z = 0; } solve() { let _this = this.v1; let local = this.lp1; let this1 = _this.av; let angle = Math.sqrt(this1.x * this1.x + this1.y * this1.y + this1.z * this1.z); let this2 = _this.av; let l = Math.sqrt(this2.x * this2.x + this2.y * this2.y + this2.z * this2.z); if(l > 0) { l = 1 / l; } let sinHalfAngle = Math.sin(angle * 0.5); let cosHalfAngle = Math.cos(angle * 0.5); let x = this2.x * l * sinHalfAngle; let y = this2.y * l * sinHalfAngle; let z = this2.z * l * sinHalfAngle; let b = _this.q; let x1 = cosHalfAngle * b.x + x * b.w + y * b.z - z * b.y; let y1 = cosHalfAngle * b.y - x * b.z + y * b.w + z * b.x; let z1 = cosHalfAngle * b.z + x * b.y - y * b.x + z * b.w; let w = cosHalfAngle * b.w - x * b.x - y * b.y - z * b.z; let x2 = x1 * 2; let y2 = y1 * 2; let z2 = z1 * 2; let xx = x1 * x2; let yy = y1 * y2; let zz = z1 * z2; let xy = x1 * y2; let yz = y1 * z2; let xz = x1 * z2; let wx = w * x2; let wy = w * y2; let wz = w * z2; let x3 = (1 - yy - zz) * local.x + (xy - wz) * local.y + (xz + wy) * local.z; let y3 = (xy + wz) * local.x + (1 - xx - zz) * local.y + (yz - wx) * local.z; let z3 = (xz - wy) * local.x + (yz + wx) * local.y + (1 - xx - yy) * local.z; let _this1 = this.v2; let local1 = this.lp2; let this3 = _this1.av; let angle1 = Math.sqrt(this3.x * this3.x + this3.y * this3.y + this3.z * this3.z); let this4 = _this1.av; let l1 = Math.sqrt(this4.x * this4.x + this4.y * this4.y + this4.z * this4.z); if(l1 > 0) { l1 = 1 / l1; } let sinHalfAngle1 = Math.sin(angle1 * 0.5); let cosHalfAngle1 = Math.cos(angle1 * 0.5); let x4 = this4.x * l1 * sinHalfAngle1; let y4 = this4.y * l1 * sinHalfAngle1; let z4 = this4.z * l1 * sinHalfAngle1; let b1 = _this1.q; let x5 = cosHalfAngle1 * b1.x + x4 * b1.w + y4 * b1.z - z4 * b1.y; let y5 = cosHalfAngle1 * b1.y - x4 * b1.z + y4 * b1.w + z4 * b1.x; let z5 = cosHalfAngle1 * b1.z + x4 * b1.y - y4 * b1.x + z4 * b1.w; let w1 = cosHalfAngle1 * b1.w - x4 * b1.x - y4 * b1.y - z4 * b1.z; let x21 = x5 * 2; let y21 = y5 * 2; let z21 = z5 * 2; let xx1 = x5 * x21; let yy1 = y5 * y21; let zz1 = z5 * z21; let xy1 = x5 * y21; let yz1 = y5 * z21; let xz1 = x5 * z21; let wx1 = w1 * x21; let wy1 = w1 * y21; let wz1 = w1 * z21; let x6 = (1 - yy1 - zz1) * local1.x + (xy1 - wz1) * local1.y + (xz1 + wy1) * local1.z; let y6 = (xy1 + wz1) * local1.x + (1 - xx1 - zz1) * local1.y + (yz1 - wx1) * local1.z; let z6 = (xz1 - wy1) * local1.x + (yz1 + wx1) * local1.y + (1 - xx1 - yy1) * local1.z; let this5 = this.p1; let a = this.v1.p; let b2 = this.v1.lv; this5.x = a.x + b2.x + x3; this5.y = a.y + b2.y + y3; this5.z = a.z + b2.z + z3; let this6 = this.p2; let a1 = this.v2.p; let b3 = this.v2.lv; this6.x = a1.x + b3.x + x6; this6.y = a1.y + b3.y + y6; this6.z = a1.z + b3.z + z6; let a2 = this.p2; let b4 = this.p1; let x7 = a2.x - b4.x; let y7 = a2.y - b4.y; let z7 = a2.z - b4.z; let this7 = this.effectiveMass; let x8 = this7.e00 * x7 + this7.e01 * y7 + this7.e02 * z7; let y8 = this7.e10 * x7 + this7.e11 * y7 + this7.e12 * z7; let z8 = this7.e20 * x7 + this7.e21 * y7 + this7.e22 * z7; let a3 = this.imp; a3.x = a3.x + x8; a3.y = a3.y + y8; a3.z = a3.z + z8; let _this2 = this.v1; let a4 = _this2.lv; let lhs = _this2.invM; a4.x = a4.x + x8 * lhs; a4.y = a4.y + y8 * lhs; a4.z = a4.z + z8 * lhs; let a5 = _this2.av; let lhs1 = _this2.invI; a5.x = a5.x + (y3 * z8 - z3 * y8) * lhs1; a5.y = a5.y + (z3 * x8 - x3 * z8) * lhs1; a5.z = a5.z + (x3 * y8 - y3 * x8) * lhs1; let _this3 = this.v2; let x9 = -x8; let y9 = -y8; let z9 = -z8; let a6 = _this3.lv; let lhs2 = _this3.invM; a6.x = a6.x + x9 * lhs2; a6.y = a6.y + y9 * lhs2; a6.z = a6.z + z9 * lhs2; let a7 = _this3.av; let lhs3 = _this3.invI; a7.x = a7.x + (y6 * z9 - z6 * y9) * lhs3; a7.y = a7.y + (z6 * x9 - x6 * z9) * lhs3; a7.z = a7.z + (x6 * y9 - y6 * x9) * lhs3; let _this4 = this.v1; let this8 = _this4.av; let angle2 = Math.sqrt(this8.x * this8.x + this8.y * this8.y + this8.z * this8.z); let this9 = _this4.av; let l2 = Math.sqrt(this9.x * this9.x + this9.y * this9.y + this9.z * this9.z); if(l2 > 0) { l2 = 1 / l2; } let sinHalfAngle2 = Math.sin(angle2 * 0.5); let cosHalfAngle2 = Math.cos(angle2 * 0.5); let x10 = this9.x * l2 * sinHalfAngle2; let y10 = this9.y * l2 * sinHalfAngle2; let z10 = this9.z * l2 * sinHalfAngle2; let b5 = _this4.q; let x11 = cosHalfAngle2 * b5.x + x10 * b5.w + y10 * b5.z - z10 * b5.y; let y11 = cosHalfAngle2 * b5.y - x10 * b5.z + y10 * b5.w + z10 * b5.x; let z11 = cosHalfAngle2 * b5.z + x10 * b5.y - y10 * b5.x + z10 * b5.w; let w2 = cosHalfAngle2 * b5.w - x10 * b5.x - y10 * b5.y - z10 * b5.z; let _this5 = this.v2; let this10 = _this5.av; let angle3 = Math.sqrt(this10.x * this10.x + this10.y * this10.y + this10.z * this10.z); let this11 = _this5.av; let l3 = Math.sqrt(this11.x * this11.x + this11.y * this11.y + this11.z * this11.z); if(l3 > 0) { l3 = 1 / l3; } let sinHalfAngle3 = Math.sin(angle3 * 0.5); let cosHalfAngle3 = Math.cos(angle3 * 0.5); let x12 = this11.x * l3 * sinHalfAngle3; let y12 = this11.y * l3 * sinHalfAngle3; let z12 = this11.z * l3 * sinHalfAngle3; let b6 = _this5.q; let x13 = cosHalfAngle3 * b6.x + x12 * b6.w + y12 * b6.z - z12 * b6.y; let y13 = cosHalfAngle3 * b6.y - x12 * b6.z + y12 * b6.w + z12 * b6.x; let z13 = cosHalfAngle3 * b6.z + x12 * b6.y - y12 * b6.x + z12 * b6.w; let w3 = cosHalfAngle3 * b6.w - x12 * b6.x - y12 * b6.y - z12 * b6.z; let x22 = x11 * 2; let y22 = y11 * 2; let z22 = z11 * 2; let xx2 = x11 * x22; let yy2 = y11 * y22; let zz2 = z11 * z22; let xy2 = x11 * y22; let yz2 = y11 * z22; let xz2 = x11 * z22; let wx2 = w2 * x22; let wy2 = w2 * y22; let wz2 = w2 * z22; let a_e00 = 1 - yy2 - zz2; let a_e01 = xy2 - wz2; let a_e02 = xz2 + wy2; let a_e10 = xy2 + wz2; let a_e11 = 1 - xx2 - zz2; let a_e12 = yz2 - wx2; let a_e20 = xz2 - wy2; let a_e21 = yz2 + wx2; let a_e22 = 1 - xx2 - yy2; let x23 = x13 * 2; let y23 = y13 * 2; let z23 = z13 * 2; let xx3 = x13 * x23; let yy3 = y13 * y23; let zz3 = z13 * z23; let xy3 = x13 * y23; let yz3 = y13 * z23; let xz3 = x13 * z23; let wx3 = w3 * x23; let wy3 = w3 * y23; let wz3 = w3 * z23; let a_e001 = 1 - yy3 - zz3; let a_e011 = xy3 - wz3; let a_e021 = xz3 + wy3; let a_e101 = xy3 + wz3; let a_e111 = 1 - xx3 - zz3; let a_e121 = yz3 - wx3; let a_e201 = xz3 - wy3; let a_e211 = yz3 + wx3; let a_e221 = 1 - xx3 - yy3; let b7 = this.ex1; let x14 = a_e00 * b7.x + a_e01 * b7.y + a_e02 * b7.z; let y14 = a_e10 * b7.x + a_e11 * b7.y + a_e12 * b7.z; let z14 = a_e20 * b7.x + a_e21 * b7.y + a_e22 * b7.z; let b8 = this.ex2; let x15 = a_e001 * b8.x + a_e011 * b8.y + a_e021 * b8.z; let y15 = a_e101 * b8.x + a_e111 * b8.y + a_e121 * b8.z; let z15 = a_e201 * b8.x + a_e211 * b8.y + a_e221 * b8.z; let w4 = Math.sqrt((1 + (x14 * x15 + y14 * y15 + z14 * z15)) * 0.5); let v; if(w4 == 0) { let x = x14 * x14; let y = y14 * y14; let z = z14 * z14; let t3 = new muun_la__$Vec3_Vec3Data(0,0,1); let perp = x < y ? x < z ? new muun_la__$Vec3_Vec3Data(1,0,0) : t3 : y < z ? new muun_la__$Vec3_Vec3Data(0,1,0) : t3; let x1 = y14 * perp.z - z14 * perp.y; let y1 = z14 * perp.x - x14 * perp.z; let z1 = x14 * perp.y - y14 * perp.x; let l = Math.sqrt(x1 * x1 + y1 * y1 + z1 * z1); if(l > 0) { l = 1 / l; } v = new muun_la__$Vec3_Vec3Data(x1 * l,y1 * l,z1 * l); } else { v = new muun_la__$Vec3_Vec3Data((y14 * z15 - z14 * y15) * 0.5 / w4,(z14 * x15 - x14 * z15) * 0.5 / w4,(x14 * y15 - y14 * x15) * 0.5 / w4); } let x16 = v.x; let y16 = v.y; let z16 = v.z; let x24 = x16 * 2; let y24 = y16 * 2; let z24 = z16 * 2; let xx4 = x16 * x24; let yy4 = y16 * y24; let zz4 = z16 * z24; let xy4 = x16 * y24; let yz4 = y16 * z24; let xz4 = x16 * z24; let wx4 = w4 * x24; let wy4 = w4 * y24; let wz4 = w4 * z24; let b9 = this.ey1; let x17 = a_e00 * b9.x + a_e01 * b9.y + a_e02 * b9.z; let y17 = a_e10 * b9.x + a_e11 * b9.y + a_e12 * b9.z; let z17 = a_e20 * b9.x + a_e21 * b9.y + a_e22 * b9.z; let x18 = (1 - yy4 - zz4) * x17 + (xy4 - wz4) * y17 + (xz4 + wy4) * z17; let y18 = (xy4 + wz4) * x17 + (1 - xx4 - zz4) * y17 + (yz4 - wx4) * z17; let z18 = (xz4 - wy4) * x17 + (yz4 + wx4) * y17 + (1 - xx4 - yy4) * z17; let b10 = this.ey2; let b11 = this.ez2; let angleTwist = -Math.atan2(x18 * (a_e001 * b11.x + a_e011 * b11.y + a_e021 * b11.z) + y18 * (a_e101 * b11.x + a_e111 * b11.y + a_e121 * b11.z) + z18 * (a_e201 * b11.x + a_e211 * b11.y + a_e221 * b11.z),x18 * (a_e001 * b10.x + a_e011 * b10.y + a_e021 * b10.z) + y18 * (a_e101 * b10.x + a_e111 * b10.y + a_e121 * b10.z) + z18 * (a_e201 * b10.x + a_e211 * b10.y + a_e221 * b10.z)); let x19 = x14 + x15; let y19 = y14 + y15; let z19 = z14 + z15; let l4 = Math.sqrt(x19 * x19 + y19 * y19 + z19 * z19); if(l4 > 0) { l4 = 1 / l4; } let angleBend = Math.acos(w4 > 1 ? 1 : w4 < -1 ? -1 : w4) * 2; let l5 = Math.sqrt(x16 * x16 + y16 * y16 + z16 * z16); if(l5 > 0) { l5 = 1 / l5; } let cfmTwist = (this.v1.invI + this.v2.invI) * 0.05; let cfmBend = (this.v1.invI + this.v2.invI) * 0.05 * 3; let lhs4 = 1 / (this.v1.invI + this.v2.invI + cfmTwist); let rhs = this.angTwistImp; let x20 = (x19 * l4 * angleTwist - rhs.x * cfmTwist) * lhs4; let y20 = (y19 * l4 * angleTwist - rhs.y * cfmTwist) * lhs4; let z20 = (z19 * l4 * angleTwist - rhs.z * cfmTwist) * lhs4; let lhs5 = 1 / (this.v1.invI + this.v2.invI + cfmBend); let rhs1 = this.angBendImp; let x25 = (x16 * l5 * angleBend - rhs1.x * cfmBend) * lhs5; let y25 = (y16 * l5 * angleBend - rhs1.y * cfmBend) * lhs5; let z25 = (z16 * l5 * angleBend - rhs1.z * cfmBend) * lhs5; let a8 = this.v1.av; let b12 = this.v1.invI; a8.x = a8.x + (x20 + x25) * b12; a8.y = a8.y + (y20 + y25) * b12; a8.z = a8.z + (z20 + z25) * b12; let a9 = this.v2.av; let b13 = this.v2.invI; a9.x = a9.x - (x20 + x25) * b13; a9.y = a9.y - (y20 + y25) * b13; a9.z = a9.z - (z20 + z25) * b13; let a10 = this.angTwistImp; a10.x = a10.x + x20; a10.y = a10.y + y20; a10.z = a10.z + z20; let a11 = this.angBendImp; a11.x = a11.x + x25; a11.y = a11.y + y25; a11.z = a11.z + z25; } } Spring.__name__ = true; class Contact { constructor(v1,v2) { this.v1 = v1; this.v2 = v2; this.imp = new muun_la__$Vec3_Vec3Data(0,0,0); } solve() { let a = this.v1.p; let b = this.v1.lv; let a1 = this.v2.p; let b1 = this.v2.lv; let x = a1.x + b1.x - (a.x + b.x); let y = a1.y + b1.y - (a.y + b.y); let z = a1.z + b1.z - (a.z + b.z); let dist = Math.sqrt(x * x + y * y + z * z); let newImp = new muun_la__$Vec3_Vec3Data(0,0,0); if(dist < 0.6) { let l = Math.sqrt(x * x + y * y + z * z); if(l > 0) { l = 1 / l; } let overlap = 0.6 - dist; let effectiveMass = 1 / (this.v1.invM + this.v2.invM); newImp = new muun_la__$Vec3_Vec3Data(-(x * l) * overlap * effectiveMass,-(y * l) * overlap * effectiveMass,-(z * l) * overlap * effectiveMass); let a = this.v1.lv; let b = this.v1.invM; a.x = a.x + newImp.x * b; a.y = a.y + newImp.y * b; a.z = a.z + newImp.z * b; let a1 = this.v2.lv; let b1 = this.v2.invM; a1.x = a1.x - newImp.x * b1; a1.y = a1.y - newImp.y * b1; a1.z = a1.z - newImp.z * b1; } } } Contact.__name__ = true; class World { constructor() { this.vs = []; this.ss = []; this.cs = []; this.cables = []; } update() { this.cs.length = 0; let n = this.vs.length; let shift = Math.round(2.9999999999999996) + 1; let _g = 0; while(_g < n) { let i = _g++; let _g1 = i + shift; while(_g1 < n) { let v1 = this.vs[i]; let v2 = this.vs[_g1++]; if(v1.invM == 0 && v2.invM == 0) { continue; } let a = v1.p; let b = v2.p; let x = a.x - b.x; let y = a.y - b.y; let z = a.z - b.z; if(Math.sqrt(x * x + y * y + z * z) < 0.75) { this.cs.push(new Contact(v1,v2)); } } } let _g1 = 0; let _g2 = this.ss; while(_g1 < _g2.length) _g2[_g1++].preSolve(); let ss2 = this.ss.slice(); let _g3 = 0; while(_g3 < 20) { ++_g3; let _g = 1; let _g1 = ss2.length; while(_g < _g1) { let i = _g++; let j = Std.random(i + 1); let tmp = ss2[i]; ss2[i] = ss2[j]; ss2[j] = tmp; } let _g2 = 0; while(_g2 < ss2.length) ss2[_g2++].solve(); let _g4 = 0; let _g5 = this.cs; while(_g4 < _g5.length) _g5[_g4++].solve(); } let _g4 = 0; let _g5 = this.vs; while(_g4 < _g5.length) _g5[_g4++].update(); } draw(g) { let _g = 0; let _g1 = this.cables; while(_g < _g1.length) _g1[_g++].draw(g); } } World.__name__ = true; class Cable { constructor(vs) { this.vs = vs; } draw(g) { g.beginShape(4); let n = this.vs.length; let pe1_x = 0; let pe1_y = 0; let pe1_z = 0; let pe2_x = 0; let pe2_y = 0; let pe2_z = 0; let pe3 = new muun_la__$Vec3_Vec3Data(0,0,0); let pv1_x = 0; let pv1_y = 0; let pv1_z = 0; let pv2_x = 0; let pv2_y = 0; let pv2_z = 0; let pv3_x = 0; let pv3_y = 0; let pv3_z = 0; let pv4_x = 0; let pv4_y = 0; let pv4_z = 0; let first = true; let radius = 0.3 / Math.sqrt(2); let _g = 1; while(_g < n) { let i = _g++; let v1 = this.vs[i - 1]; let v2 = this.vs[i]; let t1; if(i == 1) { t1 = new muun_la__$Vec3_Vec3Data(0,0,0); } else { let a = v1.p; let b = this.vs[i - 2].p; t1 = new muun_la__$Vec3_Vec3Data(a.x - b.x,a.y - b.y,a.z - b.z); } let t2; if(i == n - 1) { t2 = new muun_la__$Vec3_Vec3Data(0,0,0); } else { let a = this.vs[i + 1].p; let b = v2.p; t2 = new muun_la__$Vec3_Vec3Data(a.x - b.x,a.y - b.y,a.z - b.z); } t1.x = t1.x * 0.5; t1.y = t1.y * 0.5; t1.z = t1.z * 0.5; t2.x = t2.x * 0.5; t2.y = t2.y * 0.5; t2.z = t2.z * 0.5; let _g1 = 0; let _g2 = i == n - 1 ? [0,0.25,0.5,0.75,1] : [0,0.25,0.5,0.75]; while(_g1 < _g2.length) { let t = _g2[_g1]; ++_g1; let p_x = 0; let p_y = 0; let p_z = 0; let r = new muun_la__$Mat3_Mat3Data(0,0,0,0,0,0,0,0,0); let p1 = v1.p; let p2 = v2.p; let lhs = 2 * t * t * t - 3 * t * t + 1; let lhs1 = t * t * t - 2 * t * t + t; let rhs = t1; let lhs2 = -2 * t * t * t + 3 * t * t; let lhs3 = t * t * t - t * t; let rhs1 = t2; p_x = p1.x * lhs + rhs.x * lhs1 + p2.x * lhs2 + rhs1.x * lhs3; p_y = p1.y * lhs + rhs.y * lhs1 + p2.y * lhs2 + rhs1.y * lhs3; p_z = p1.z * lhs + rhs.z * lhs1 + p2.z * lhs2 + rhs1.z * lhs3; let q1 = v1.q; let q2 = v2.q; let b = v2.q; let a = v1.q; let dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; if(dot < 0) { q2 = new muun_la__$Quat_QuatData(-q2.x,-q2.y,-q2.z,-q2.w); dot = -dot; } if(dot >= 1) { let m = v1.r; r.e00 = m.e00; r.e01 = m.e01; r.e02 = m.e02; r.e10 = m.e10; r.e11 = m.e11; r.e12 = m.e12; r.e20 = m.e20; r.e21 = m.e21; r.e22 = m.e22; } else { let ang = Math.acos(dot); let sin = Math.sin(ang); if(sin <= 0) { let m = v1.r; r.e00 = m.e00; r.e01 = m.e01; r.e02 = m.e02; r.e10 = m.e10; r.e11 = m.e11; r.e12 = m.e12; r.e20 = m.e20; r.e21 = m.e21; r.e22 = m.e22; } else { let coeff1 = Math.sin((1 - t) * ang) / sin; let coeff2 = Math.sin(t * ang) / sin; let x = q1.x * coeff1 + q2.x * coeff2; let y = q1.y * coeff1 + q2.y * coeff2; let z = q1.z * coeff1 + q2.z * coeff2; let w = q1.w * coeff1 + q2.w * coeff2; let x2 = x * 2; let y2 = y * 2; let z2 = z * 2; let xx = x * x2; let yy = y * y2; let zz = z * z2; let xy = x * y2; let yz = y * z2; let xz = x * z2; let wx = w * x2; let wy = w * y2; let wz = w * z2; r.e00 = 1 - yy - zz; r.e01 = xy - wz; r.e02 = xz + wy; r.e10 = xy + wz; r.e11 = 1 - xx - zz; r.e12 = yz - wx; r.e20 = xz - wy; r.e21 = yz + wx; r.e22 = 1 - xx - yy; } } let b_x = 1; let b_y = 0; let b_z = 0; let a1 = r; let x = a1.e00 * b_x + a1.e01 * b_y + a1.e02 * b_z; let y = a1.e10 * b_x + a1.e11 * b_y + a1.e12 * b_z; let z = a1.e20 * b_x + a1.e21 * b_y + a1.e22 * b_z; let b_x1 = 0; let b_y1 = 0; let b_z1 = 1; let a2 = r; let x1 = a2.e00 * b_x1 + a2.e01 * b_y1 + a2.e02 * b_z1; let y1 = a2.e10 * b_x1 + a2.e11 * b_y1 + a2.e12 * b_z1; let z1 = a2.e20 * b_x1 + a2.e21 * b_y1 + a2.e22 * b_z1; let b_x2 = 0; let b_y2 = 1; let b_z2 = 0; let a3 = r; let x2 = a3.e00 * b_x2 + a3.e01 * b_y2 + a3.e02 * b_z2; let y2 = a3.e10 * b_x2 + a3.e11 * b_y2 + a3.e12 * b_z2; let z2 = a3.e20 * b_x2 + a3.e21 * b_y2 + a3.e22 * b_z2; let x3 = p_x + (-x - x1) * radius; let y3 = p_y + (-y - y1) * radius; let z3 = p_z + (-z - z1) * radius; let x4 = p_x + (-x + x1) * radius; let y4 = p_y + (-y + y1) * radius; let z4 = p_z + (-z + z1) * radius; let x5 = p_x + (x + x1) * radius; let y5 = p_y + (y + y1) * radius; let z5 = p_z + (z + z1) * radius; let x6 = p_x + (x - x1) * radius; let y6 = p_y + (y - y1) * radius; let z6 = p_z + (z - z1) * radius; if(first) { first = false; g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(x4,y4,z4); g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(x5,y5,z5); g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(x3,y3,z3); g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(x6,y6,z6); g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(x3,y3,z3); g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(x5,y5,z5); } else { let x2 = -pe1_x; let y2 = -pe1_y; let z2 = -pe1_z; let x7 = -x; let y7 = -y; let z7 = -z; g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(pv1_x,pv1_y,pv1_z); g.normalX = x7; g.normalY = y7; g.normalZ = z7; g.vertex(x3,y3,z3); g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(pv2_x,pv2_y,pv2_z); g.normalX = x7; g.normalY = y7; g.normalZ = z7; g.vertex(x4,y4,z4); g.normalX = x2; g.normalY = y2; g.normalZ = z2; g.vertex(pv2_x,pv2_y,pv2_z); g.normalX = x7; g.normalY = y7; g.normalZ = z7; g.vertex(x3,y3,z3); g.normalX = pe2_x; g.normalY = pe2_y; g.normalZ = pe2_z; g.vertex(pv2_x,pv2_y,pv2_z); g.normalX = x1; g.normalY = y1; g.normalZ = z1; g.vertex(x4,y4,z4); g.normalX = pe2_x; g.normalY = pe2_y; g.normalZ = pe2_z; g.vertex(pv3_x,pv3_y,pv3_z); g.normalX = x1; g.normalY = y1; g.normalZ = z1; g.vertex(x5,y5,z5); g.normalX = pe2_x; g.normalY = pe2_y; g.normalZ = pe2_z; g.vertex(pv3_x,pv3_y,pv3_z); g.normalX = x1; g.normalY = y1; g.normalZ = z1; g.vertex(x4,y4,z4); g.normalX = pe1_x; g.normalY = pe1_y; g.normalZ = pe1_z; g.vertex(pv3_x,pv3_y,pv3_z); g.normalX = x; g.normalY = y; g.normalZ = z; g.vertex(x5,y5,z5); g.normalX = pe1_x; g.normalY = pe1_y; g.normalZ = pe1_z; g.vertex(pv4_x,pv4_y,pv4_z); g.normalX = x; g.normalY = y; g.normalZ = z; g.vertex(x6,y6,z6); g.normalX = pe1_x; g.normalY = pe1_y; g.normalZ = pe1_z; g.vertex(pv4_x,pv4_y,pv4_z); g.normalX = x; g.normalY = y; g.normalZ = z; g.vertex(x5,y5,z5); let x8 = -pe2_x; let y8 = -pe2_y; let z8 = -pe2_z; let x9 = -x1; let y9 = -y1; let z9 = -z1; g.normalX = x8; g.normalY = y8; g.normalZ = z8; g.vertex(pv4_x,pv4_y,pv4_z); g.normalX = x9; g.normalY = y9; g.normalZ = z9; g.vertex(x6,y6,z6); g.normalX = x8; g.normalY = y8; g.normalZ = z8; g.vertex(pv1_x,pv1_y,pv1_z); g.normalX = x9; g.normalY = y9; g.normalZ = z9; g.vertex(x3,y3,z3); g.normalX = x8; g.normalY = y8; g.normalZ = z8; g.vertex(pv1_x,pv1_y,pv1_z); g.normalX = x9; g.normalY = y9; g.normalZ = z9; g.vertex(x6,y6,z6); } pv1_x = x3; pv1_y = y3; pv1_z = z3; pv2_x = x4; pv2_y = y4; pv2_z = z4; pv3_x = x5; pv3_y = y5; pv3_z = z5; pv4_x = x6; pv4_y = y6; pv4_z = z6; pe1_x = x; pe1_y = y; pe1_z = z; pe2_x = x1; pe2_y = y1; pe2_z = z1; pe3.x = x2; pe3.y = y2; pe3.z = z2; } } let x = -pe3.x; let y = -pe3.y; let z = -pe3.z; let x1 = -pe3.x; let y1 = -pe3.y; let z1 = -pe3.z; g.normalX = x; g.normalY = y; g.normalZ = z; g.vertex(pv1_x,pv1_y,pv1_z); g.normalX = x1; g.normalY = y1; g.normalZ = z1; g.vertex(pv4_x,pv4_y,pv4_z); g.normalX = x; g.normalY = y; g.normalZ = z; g.vertex(pv2_x,pv2_y,pv2_z); g.normalX = x1; g.normalY = y1; g.normalZ = z1; g.vertex(pv3_x,pv3_y,pv3_z); g.normalX = x; g.normalY = y; g.normalZ = z; g.vertex(pv2_x,pv2_y,pv2_z); g.normalX = x1; g.normalY = y1; g.normalZ = z1; g.vertex(pv4_x,pv4_y,pv4_z); g.endShape(); } } Cable.__name__ = true; class pot_core_App { constructor(canvas,captureInput) { if(pot_core_App._hx_skip_constructor) { return; } this._hx_constructor(canvas,captureInput); } _hx_constructor(canvas,captureInput) { if(captureInput == null) { captureInput = true; } this.canvas = canvas; this.pot = new pot_core_Pot(this,canvas); if(captureInput) { this.input = new pot_input_Input(canvas,this.pot); } else { this.input = null; } this.frameCount = 0; this.setup(); } setup() { } loop() { } } pot_core_App.__name__ = true; class CableSim extends pot_core_App { constructor(canvas,captureInput) { pot_core_App._hx_skip_constructor = true; super(); pot_core_App._hx_skip_constructor = false; this._hx_constructor(canvas,captureInput); } _hx_constructor(canvas,captureInput) { this.target = new muun_la__$Vec3_Vec3Data(0,0,0); super._hx_constructor(canvas,captureInput); } setup() { this.pot.resize(window.innerWidth,window.innerHeight,window.devicePixelRatio); this.pot.frameRate(0); let _gthis = this; window.addEventListener("resize",function() { _gthis.pot.resize(window.innerWidth,window.innerHeight,window.devicePixelRatio); let _this = _gthis.g; let height = _gthis.canvas.height; _this.screenWidth = _gthis.canvas.width; _this.screenHeight = height; if(_this.currentRenderTarget == null) { let width; let height; let targetHeight; if(_this.currentRenderTarget == null) { width = _this.canvas.width; height = _this.canvas.height; targetHeight = height; } else { width = _this.currentRenderTarget.width; height = _this.currentRenderTarget.height; targetHeight = _this.currentRenderTarget.textureHeight; } _this.gl.viewport(0,targetHeight - height,width,height); } let fovY = null; let far = null; fovY = Math.PI / 3; far = 10000; _this.cameraFov = fovY; _this.cameraNear = 0.1; _this.cameraFar = far; _this.projMat.perspective(fovY,_this.screenWidth / _this.screenHeight,0.1,far); }); window.setTimeout(($_=this.pot,$bind($_,$_.start)),500); this.g = new pot_graphics_Graphics(this.canvas); this.g.init3D(); this.idleCount = 0; this.initScene(); } createCable(initPos,dir,n) { let vs = []; let _g = 0; while(_g < n) { let i = _g++; let v = new Vertex(new muun_la__$Vec3_Vec3Data(initPos.x + dir.x * 0.2 * i,initPos.y + dir.y * 0.2 * i,initPos.z + dir.z * 0.2 * i),i == 0,i == 0); let this1 = v.q; let x = -0; let y = -1; let z = -0; let w = Math.sqrt((1 + (x * dir.x + y * dir.y + z * dir.z)) * 0.5); let v1; if(w == 0) { let perp = new muun_la__$Vec3_Vec3Data(0,0,1); let x1 = y * perp.z - z * perp.y; let y1 = z * perp.x - x * perp.z; let z1 = x * perp.y - y * perp.x; let l = Math.sqrt(x1 * x1 + y1 * y1 + z1 * z1); if(l > 0) { l = 1 / l; } v1 = new muun_la__$Vec3_Vec3Data(x1 * l,y1 * l,z1 * l); } else { v1 = new muun_la__$Vec3_Vec3Data((y * dir.z - z * dir.y) * 0.5 / w,(z * dir.x - x * dir.z) * 0.5 / w,(x * dir.y - y * dir.x) * 0.5 / w); } this1.x = v1.x; this1.y = v1.y; this1.z = v1.z; this1.w = w; let this2 = v.r; let this3 = v.q; let x2 = this3.x * 2; let y2 = this3.y * 2; let z2 = this3.z * 2; let xx = this3.x * x2; let yy = this3.y * y2; let zz = this3.z * z2; let xy = this3.x * y2; let yz = this3.y * z2; let xz = this3.x * z2; let wx = this3.w * x2; let wy = this3.w * y2; let wz = this3.w * z2; this2.e00 = 1 - yy - zz; this2.e01 = xy - wz; this2.e02 = xz + wy; this2.e10 = xy + wz; this2.e11 = 1 - xx - zz; this2.e12 = yz - wx; this2.e20 = xz - wy; this2.e21 = yz + wx; this2.e22 = 1 - xx - yy; vs.push(v); } let _g1 = 1; while(_g1 < n) { let i = _g1++; let v1 = vs[i - 1]; let v2 = vs[i]; let a = v1.p; let b = v2.p; this.w.ss.push(new Spring(v1,v2,new muun_la__$Vec3_Vec3Data((a.x + b.x) * 0.5,(a.y + b.y) * 0.5,(a.z + b.z) * 0.5))); } let _g2 = 0; while(_g2 < vs.length) this.w.vs.push(vs[_g2++]); this.w.cables.push(new Cable(vs)); return vs; } initScene() { this.w = new World(); let first = null; let last = null; let _g = -3; while(_g < 4) { let i = _g++; let _g1 = 0; while(_g1 < 1) { let j = _g1++; let vs = this.createCable(new muun_la__$Vec3_Vec3Data(i * 0.7,2.5,j * 0.7),new muun_la__$Vec3_Vec3Data(-0,-1,-0),30); if(i == 0 && j == 0) { first = vs[0]; last = vs[vs.length - 1]; } } } this.twist = true; this.rotating = first; this.moving = last; } loop() { let touching = this.input.touches.touches.length > 0; let clicking = this.input.mouse.left; let screenX; let screenY; let a_x = 2; let a_y = 3; let a_z = 7; let screenScale = Math.min(1,this.canvas.width / this.canvas.height); let halfScreenHeight = Math.tan(30 * Math.PI / 180); if(touching || clicking) { this.idleCount = 0; screenX = (touching ? this.input.touches.touches[0].x : this.input.mouse.x) / this.canvas.width * 2 - 1; screenY = 1 - (touching ? this.input.touches.touches[0].y : this.input.mouse.y) / this.canvas.height * 2; let l = Math.sqrt(a_x * a_x + a_y * a_y + a_z * a_z); if(l > 0) { l = 1 / l; } let x = a_x * l; let y = a_y * l; let z = a_z * l; let a_x1 = 0; let a_y1 = 1; let a_z1 = 0; let x1 = a_y1 * z - a_z1 * y; let y1 = a_z1 * x - a_x1 * z; let z1 = a_x1 * y - a_y1 * x; let l1 = Math.sqrt(x1 * x1 + y1 * y1 + z1 * z1); if(l1 > 0) { l1 = 1 / l1; } let x2 = x1 * l1; let y2 = y1 * l1; let z2 = z1 * l1; let a_x2 = screenX * (halfScreenHeight * this.canvas.width / this.canvas.height); let a_y2 = screenY * halfScreenHeight; let a_z2 = -1; let l2 = Math.sqrt(a_x2 * a_x2 + a_y2 * a_y2 + a_z2 * a_z2); if(l2 > 0) { l2 = 1 / l2; } let dir = new muun_la__$Vec3_Vec3Data(a_x2 * l2,a_y2 * l2,a_z2 * l2); let lhs = dir.x; let lhs1 = dir.y; let lhs2 = dir.z; dir = new muun_la__$Vec3_Vec3Data(x2 * lhs + (y * z2 - z * y2) * lhs1 + x * lhs2,y2 * lhs + (z * x2 - x * z2) * lhs1 + y * lhs2,z2 * lhs + (x * y2 - y * x2) * lhs1 + z * lhs2); let dist = Math.sqrt(a_x * a_x + a_y * a_y + a_z * a_z); let this1 = this.target; this1.x = (a_x + dir.x * dist) / screenScale; this1.y = (a_y + dir.y * dist) / screenScale; this1.z = (a_z + dir.z * dist) / screenScale; let a = this.moving.p; let a1 = this.target; let b = this.moving.p; a.x = a.x + (a1.x - b.x) * 0.3; a.y = a.y + (a1.y - b.y) * 0.3; a.z = a.z + (a1.z - b.z) * 0.3; let a2 = this.moving.lv; let a3 = this.target; let b1 = this.moving.p; a2.x = a2.x + (a3.x - b1.x) * 0.2; a2.y = a2.y + (a3.y - b1.y) * 0.2; a2.z = a2.z + (a3.z - b1.z) * 0.2; } if(++this.idleCount > 120) { clicking = true; let ang = (this.idleCount - 120) * 0.02; let this1 = this.target; let z = Math.sin(2 * ang) * 2; this1.x = Math.sin(ang) * 4; this1.y = -2; this1.z = z; let a = this.moving.p; let a1 = this.target; let b = this.moving.p; a.x = a.x + (a1.x - b.x) * 0.2; a.y = a.y + (a1.y - b.y) * 0.2; a.z = a.z + (a1.z - b.z) * 0.2; let a2 = this.moving.lv; let a3 = this.target; let b1 = this.moving.p; a2.x = a2.x + (a3.x - b1.x) * 0.1; a2.y = a2.y + (a3.y - b1.y) * 0.1; a2.z = a2.z + (a3.z - b1.z) * 0.1; } this.w.update(); let _this = this.g; _this.cameraSet = true; _this.cameraPosX = a_x; _this.cameraPosY = a_y; _this.cameraPosZ = a_z; _this.cameraAtX = 0; _this.cameraAtY = 0; _this.cameraAtZ = 0; _this.cameraUpX = 0; _this.cameraUpY = 1; _this.cameraUpZ = 0; _this.viewMat.lookAt(_this.cameraPosX,_this.cameraPosY,_this.cameraPosZ,_this.cameraAtX,_this.cameraAtY,_this.cameraAtZ,_this.cameraUpX,_this.cameraUpY,_this.cameraUpZ); let _this1 = this.g; _this1.beginScene(); let _this2 = this.g; if(_this2.sceneOpen != true) { throw new Error("begin scene before clear scene"); } _this2.gl.clearColor(0.3,0.3,0.3,1); _this2.gl.clearDepth(1); _this2.gl.clear(16640); let _this3 = this.g; if(_this3.sceneOpen != true) { throw new Error("begin scene before setting lights"); } if(_this3.numLights == 8) { throw new Error("too many lights"); } let light = _this3.lightBuf[_this3.numLights++]; light.r = 0.2; light.g = 0.2; light.b = 0.2; light.posX = 0; light.posY = 0; light.posZ = 0; light.posW = 0; light.norX = 0; light.norY = 0; light.norZ = 0; let dirX = -_this3.viewMat.array[2]; let dirY = -_this3.viewMat.array[6]; let dirZ = -_this3.viewMat.array[10]; if(_this3.sceneOpen != true) { throw new Error("begin scene before setting lights"); } if(_this3.numLights == 8) { throw new Error("too many lights"); } let light1 = _this3.lightBuf[_this3.numLights++]; let invLen = Math.sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ); if(invLen > 0) { invLen = 1 / invLen; } dirX *= invLen; dirY *= invLen; dirZ *= invLen; light1.r = 0.8; light1.g = 0.8; light1.b = 0.8; light1.posX = 0; light1.posY = 0; light1.posZ = 0; light1.posW = 0; light1.norX = dirX; light1.norY = dirY; light1.norZ = dirZ; let _this4 = this.g; _this4.colorR = 1; _this4.colorG = 1; _this4.colorB = 1; _this4.colorA = 1; let _this5 = this.g; if(_this5.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this5.materialShn = 8; let _this6 = this.g; if(_this6.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this6.materialSpc = 1; let _this7 = this.g; if(_this7.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this7.materialDif = 1; let sz = screenScale; if(screenScale == null) { sz = 1; } this.g.modelMat.appendScale(screenScale,screenScale,sz); this.w.draw(this.g); this.g.pushMatrix(); this.g.modelMat.appendTranslation(0,-4,0); this.g.modelMat.appendScale(1,0,1); let _this8 = this.g; if(_this8.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this8.materialSpc = 0; let _this9 = this.g; if(_this9.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this9.materialDif = 0; let _this10 = this.g; if(_this10.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this10.materialEmi = 1; let _this11 = this.g; _this11.colorR = 0.1; _this11.colorG = 0.1; _this11.colorB = 0.1; _this11.colorA = 1; this.w.draw(this.g); this.g.popMatrix(); if(clicking || touching) { this.g.pushMatrix(); let from = this.moving.p; let to = this.target; let a_x = 1; let a_y = 0; let a_z = 0; let x = to.x - from.x; let y = to.y - from.y; let z = to.z - from.z; let l = Math.sqrt(x * x + y * y + z * z); if(l > 0) { l = 1 / l; } let x1 = x * l; let y1 = y * l; let z1 = z * l; let w = Math.sqrt((1 + (a_x * x1 + a_y * y1 + a_z * z1)) * 0.5); let v; if(w == 0) { let perp = new muun_la__$Vec3_Vec3Data(0,0,1); let x = a_y * perp.z - a_z * perp.y; let y = a_z * perp.x - a_x * perp.z; let z = a_x * perp.y - a_y * perp.x; let l = Math.sqrt(x * x + y * y + z * z); if(l > 0) { l = 1 / l; } v = new muun_la__$Vec3_Vec3Data(x * l,y * l,z * l); } else { v = new muun_la__$Vec3_Vec3Data((a_y * z1 - a_z * y1) * 0.5 / w,(a_z * x1 - a_x * z1) * 0.5 / w,(a_x * y1 - a_y * x1) * 0.5 / w); } let x2 = v.x; let y2 = v.y; let z2 = v.z; let x21 = x2 * 2; let y21 = y2 * 2; let z21 = z2 * 2; let xx = x2 * x21; let yy = y2 * y21; let zz = z2 * z21; let xy = x2 * y21; let yz = y2 * z21; let xz = x2 * z21; let wx = w * x21; let wy = w * y21; let wz = w * z21; this.g.modelMat.appendTransform(1 - yy - zz,xy - wz,xz + wy,(from.x + to.x) * 0.5,xy + wz,1 - xx - zz,yz - wx,(from.y + to.y) * 0.5,xz - wy,yz + wx,1 - xx - yy,(from.z + to.z) * 0.5,0,0,0,1); let _this = this.g; if(_this.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this.materialEmi = 1; let _this1 = this.g; if(_this1.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this1.materialDif = 0; let _this2 = this.g; if(_this2.sceneOpen != true) { throw new Error("begin scene before setting materials"); } _this2.materialSpc = 0; let _this3 = this.g; _this3.colorR = 1; _this3.colorG = 0.0; _this3.colorB = 0.0; _this3.colorA = 1; let x3 = to.x - from.x; let y3 = to.y - from.y; let z3 = to.z - from.z; this.g.box(Math.sqrt(x3 * x3 + y3 * y3 + z3 * z3),0.1,0.1); this.g.popMatrix(); } if(_this1.sceneOpen != true) { throw new Error("scene already ended"); } _this1.sceneOpen = false; _this1.gl.flush(); } static main() { new CableSim(window.document.getElementById("canvas")); } } CableSim.__name__ = true; function CableSim_rand(from,to) { return Math.random() * (to - from) + from; } class HxOverrides { static remove(a,obj) { let i = a.indexOf(obj); if(i == -1) { return false; } a.splice(i,1); return true; } static now() { return Date.now(); } } HxOverrides.__name__ = true; Math.__name__ = true; class Std { static string(s) { return js_Boot.__string_rec(s,""); } static random(x) { if(x <= 0) { return 0; } else { return Math.floor(Math.random() * x); } } } Std.__name__ = true; class haxe_Exception extends Error { constructor(message,previous,native) { super(message); this.message = message; this.__previousException = previous; this.__nativeException = native != null ? native : this; } unwrap() { return this.__nativeException; } get_native() { return this.__nativeException; } static caught(value) { if(((value) instanceof haxe_Exception)) { return value; } else if(((value) instanceof Error)) { return new haxe_Exception(value.message,null,value); } else { return new haxe_ValueException(value,null,value); } } static thrown(value) { if(((value) instanceof haxe_Exception)) { return value.get_native(); } else if(((value) instanceof Error)) { return value; } else { let e = new haxe_ValueException(value); return e; } } } haxe_Exception.__name__ = true; class haxe_ValueException extends haxe_Exception { constructor(value,previous,native) { super(String(value),previous,native); this.value = value; } unwrap() { return this.value; } } haxe_ValueException.__name__ = true; class haxe_ds_StringMap { constructor() { this.h = Object.create(null); } } haxe_ds_StringMap.__name__ = true; class haxe_iterators_ArrayIterator { constructor(array) { this.current = 0; this.array = array; } hasNext() { return this.current < this.array.length; } next() { return this.array[this.current++]; } } haxe_iterators_ArrayIterator.__name__ = true; class js_Boot { static __string_rec(o,s) { if(o == null) { return "null"; } if(s.length >= 5) { return "<...>"; } let t = typeof(o); if(t == "function" && (o.__name__ || o.__ename__)) { t = "object"; } switch(t) { case "function": return ""; case "object": if(((o) instanceof Array)) { let str = "["; s += "\t"; let _g = 0; let _g1 = o.length; while(_g < _g1) { let i = _g++; str += (i > 0 ? "," : "") + js_Boot.__string_rec(o[i],s); } str += "]"; return str; } let tostr; try { tostr = o.toString; } catch( _g ) { return "???"; } if(tostr != null && tostr != Object.toString && typeof(tostr) == "function") { let s2 = o.toString(); if(s2 != "[object Object]") { return s2; } } let str = "{\n"; s += "\t"; let hasp = o.hasOwnProperty != null; let k = null; for( k in o ) { if(hasp && !o.hasOwnProperty(k)) { continue; } if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__" || k == "__properties__") { continue; } if(str.length != 2) { str += ", \n"; } str += s + k + " : " + js_Boot.__string_rec(o[k],s); } s = s.substring(1); str += "\n" + s + "}"; return str; case "string": return o; default: return String(o); } } } js_Boot.__name__ = true; class js_html__$CanvasElement_CanvasUtil { static getContextWebGL(canvas,attribs) { let ctx = canvas.getContext("webgl",attribs); if(ctx != null) { return ctx; } let ctx1 = canvas.getContext("experimental-webgl",attribs); if(ctx1 != null) { return ctx1; } return null; } } js_html__$CanvasElement_CanvasUtil.__name__ = true; class muun_la__$Mat3_Mat3Data { constructor(e00,e01,e02,e10,e11,e12,e20,e21,e22) { this.e00 = e00; this.e01 = e01; this.e02 = e02; this.e10 = e10; this.e11 = e11; this.e12 = e12; this.e20 = e20; this.e21 = e21; this.e22 = e22; } } muun_la__$Mat3_Mat3Data.__name__ = true; class muun_la__$Quat_QuatData { constructor(x,y,z,w) { this.x = x; this.y = y; this.z = z; this.w = w; } } muun_la__$Quat_QuatData.__name__ = true; class muun_la__$Vec3_Vec3Data { constructor(x,y,z) { this.x = x; this.y = y; this.z = z; } } muun_la__$Vec3_Vec3Data.__name__ = true; class pot_core_Pot { constructor(app,canvas) { this.app = app; this.canvas = canvas; this.timer = new pot_util_Timer($bind(this,this.frame)); } resize(width,height,pixelRatio) { if(pixelRatio == null) { pixelRatio = 1; } this.width = width; this.height = height; this.pixelRatio = pixelRatio; this.canvas.width = width * pixelRatio; this.canvas.height = height * pixelRatio; } frameRate(frameRate) { if(frameRate == 0) { this.timer.setFrameRate(60); this.timer.setUseAnimationFrame(true); } else { this.timer.setFrameRate(frameRate); } } start() { this.timer.start(); } frame() { if(this.app.input != null) { this.app.input.update(); } this.app.loop(); this.app.frameCount++; } } pot_core_Pot.__name__ = true; class pot_graphics_Graphics { constructor(canvas) { this.canvas = canvas; this.gl = js_html__$CanvasElement_CanvasUtil.getContextWebGL(canvas,null); this.initGL(); this.initShaders(); this.initBuffers(); this.initMatricies(); this.cameraNear = 0.1; this.cameraFar = 10000; this.cameraFov = Math.PI / 3; this.cameraSet = false; this.cameraPosX = 0; this.cameraPosY = 0; this.cameraPosZ = 1; this.cameraAtX = 0; this.cameraAtY = 0; this.cameraAtZ = 0; this.cameraUpX = 0; this.cameraUpY = 1; this.cameraUpZ = 0; this.screenWidth = canvas.width; this.screenHeight = canvas.height; if(this.currentRenderTarget == null) { let width; let height; let targetHeight; if(this.currentRenderTarget == null) { width = this.canvas.width; height = this.canvas.height; targetHeight = height; } else { width = this.currentRenderTarget.width; height = this.currentRenderTarget.height; targetHeight = this.currentRenderTarget.textureHeight; } this.gl.viewport(0,targetHeight - height,width,height); } let fovY = null; let far = null; fovY = Math.PI / 3; far = 10000; this.cameraFov = fovY; this.cameraNear = 0.1; this.cameraFar = far; this.projMat.perspective(fovY,this.screenWidth / this.screenHeight,0.1,far); this.numVertices = 0; this.colorR = 1; this.colorG = 1; this.colorB = 1; this.colorA = 1; this.normalX = 0; this.normalY = 0; this.normalZ = 0; this.texCoordU = 0; this.texCoordV = 0; this.matStack = new Array(1024); this.matStackCount = 0; this.currentTexture = null; this.currentRenderTarget = null; this.texMode = 1; this.sceneOpen = false; this.lightBuf = new Array(8); this.lightBuf[0] = new pot_graphics__$Graphics_Light(); this.lightBuf[1] = new pot_graphics__$Graphics_Light(); this.lightBuf[2] = new pot_graphics__$Graphics_Light(); this.lightBuf[3] = new pot_graphics__$Graphics_Light(); this.lightBuf[4] = new pot_graphics__$Graphics_Light(); this.lightBuf[5] = new pot_graphics__$Graphics_Light(); this.lightBuf[6] = new pot_graphics__$Graphics_Light(); this.lightBuf[7] = new pot_graphics__$Graphics_Light(); this.numLights = 0; } initGL() { this.gl.getExtension("OES_texture_float"); this.gl.getExtension("OES_texture_float_linear"); this.gl.getExtension("OES_texture_half_float"); this.gl.getExtension("OES_texture_half_float_linear"); this.gl.getExtension("WEBGL_color_buffer_float"); this.gl.getExtension("OES_element_index_uint"); this.gl.disable(2929); this.gl.enable(3042); this.gl.frontFace(2305); this.gl.cullFace(1029); this.gl.disable(2884); this.gl.blendFuncSeparate(770,771,1,1); } init3D() { this.gl.enable(2929); this.gl.frontFace(2305); this.gl.cullFace(1029); this.gl.enable(2884); this.cameraSet = false; let width; let height; let targetHeight; if(this.currentRenderTarget == null) { width = this.canvas.width; height = this.canvas.height; targetHeight = height; } else { width = this.currentRenderTarget.width; height = this.currentRenderTarget.height; targetHeight = this.currentRenderTarget.textureHeight; } this.gl.viewport(0,targetHeight - height,width,height); this.currentTexture = null; } initMatricies() { this.modelMat = new pot_graphics__$Graphics_UniformMatrix(); this.viewMat = new pot_graphics__$Graphics_UniformMatrix(); this.modelviewMat = new pot_graphics__$Graphics_UniformMatrix(); this.normalMat = new pot_graphics__$Graphics_UniformMatrix(); this.projMat = new pot_graphics__$Graphics_UniformMatrix(); this.mvpMat = new pot_graphics__$Graphics_UniformMatrix(); } initShaders() { let vertexSource = "\n\t\t\tattribute vec4 position;\n\t\t\tattribute vec4 color;\n\t\t\tattribute vec3 normal;\n\t\t\tattribute vec2 texCoord;\n\n\t\t\tuniform mat4 transform;\n\t\t\tuniform mat4 modelview;\n\t\t\tuniform mat3 normalMatrix;\n\n\t\t\tvarying vec4 vColor;\n\t\t\tvarying vec3 vPosition;\n\t\t\tvarying vec3 vNormal;\n\t\t\tvarying vec2 vTexCoord;\n\n\t\t\tvoid main() {\n\t\t\t\tgl_Position = transform * position;\n\n\t\t\t\tvColor = color;\n\t\t\t\tvPosition = (modelview * position).xyz;\n\t\t\t\tvNormal = normalMatrix * normal;\n\t\t\t\tvTexCoord = texCoord;\n\t\t\t}\n\t\t"; this.defaultShader = new pot_graphics_Shader(this.gl); let _this = this.defaultShader; _this.vSource = vertexSource; _this.compiled = false; let _this1 = this.defaultShader; _this1.fSource = "\n\t\t\tprecision mediump float;\n\t\t\tvarying vec4 vColor;\n\t\t\tvarying vec3 vPosition;\n\t\t\tvarying vec3 vNormal;\n\t\t\tvarying vec2 vTexCoord;\n\t\t\tuniform float ambient;\n\t\t\tuniform float diffuse;\n\t\t\tuniform float specular;\n\t\t\tuniform float shininess;\n\t\t\tuniform float emission;\n\t\t\tuniform int numLights;\n\t\t\tuniform vec4 lightPositions[8];\n\t\t\tuniform vec3 lightColors[8];\n\t\t\tuniform vec3 lightNormals[8];\n\t\t\t\n\t\t\tvec3 safeNormalize(vec3 v) {\n\t\t\t\treturn dot(v, v) > 0.0 ? normalize(v) : vec3(0);\n\t\t\t}\n\n\t\t\tvoid main() {\n\t\t\t\tif (numLights == 0) {\n\t\t\t\t\tgl_FragColor = vColor;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvec3 eye = safeNormalize(vPosition);\n\t\t\t\tvec3 n = safeNormalize(vNormal);\n\t\t\t\t\n\t\t\t\tvec3 color = vColor.xyz;\n\t\t\t\tvec3 ambientTotal = vec3(0);\n\t\t\t\tvec3 diffuseTotal = vec3(0);\n\t\t\t\tvec3 specularTotal = vec3(0);\n\t\t\t\tvec3 emissionTotal = color * emission;\n\n\t\t\t\tif (!gl_FrontFacing) n = -n;\n\n\t\t\t\tfor (int i = 0; i < 8; i++) {\n\t\t\t\t\tif (i == numLights) break;\n\t\t\t\t\tvec4 lp = lightPositions[i];\n\t\t\t\t\tvec3 lc = lightColors[i];\n\t\t\t\t\tvec3 ln = lightNormals[i];\n\t\t\t\t\tbool amb = lp.w == 0.0 && dot(ln, ln) == 0.0;\n\t\t\t\t\tbool dir = lp.w == 0.0;\n\t\t\t\t\tif (amb) {\n\t\t\t\t\t\tambientTotal += lc * color * ambient;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (!dir) {\n\t\t\t\t\t\t\tln = safeNormalize(vPosition - lp.xyz);\n\t\t\t\t\t\t\t// TODO: spot light\n\t\t\t\t\t\t}\n\t\t\t\t\t\tfloat ldot = -dot(ln, n);\n\t\t\t\t\t\tif (ldot < 0.0) ldot = 0.0;\n\t\t\t\t\t\tdiffuseTotal += lc * color * ldot * diffuse;\n\t\t\t\t\t\tif (ldot > 0.0) {\n\t\t\t\t\t\t\tvec3 reflEye = eye - 2.0 * n * dot(eye, n);\n\t\t\t\t\t\t\tfloat rdot = -dot(reflEye, ln);\n\t\t\t\t\t\t\tif (rdot < 0.0) rdot = 0.0;\n\t\t\t\t\t\t\tspecularTotal += lc * pow(rdot, shininess) * specular;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tgl_FragColor = vec4(ambientTotal + diffuseTotal + specularTotal + emissionTotal, vColor.w);\n\t\t\t}\n\t\t"; _this1.compiled = false; let _this2 = this.defaultShader; _this2.map = new haxe_ds_StringMap(); _this2.gl.shaderSource(_this2.vs,_this2.vSource); _this2.gl.compileShader(_this2.vs); if(!_this2.gl.getShaderParameter(_this2.vs,35713)) { let v = _this2.gl.getShaderInfoLog(_this2.vs) + "\nsource:\n" + _this2.vSource; window.alert(Std.string(v)); } _this2.gl.shaderSource(_this2.fs,_this2.fSource); _this2.gl.compileShader(_this2.fs); if(!_this2.gl.getShaderParameter(_this2.fs,35713)) { let v = _this2.gl.getShaderInfoLog(_this2.fs) + "\nsource:\n" + _this2.fSource; window.alert(Std.string(v)); } _this2.gl.attachShader(_this2.pg,_this2.vs); _this2.gl.attachShader(_this2.pg,_this2.fs); _this2.gl.linkProgram(_this2.pg); if(_this2.gl.getProgramParameter(_this2.pg,35714)) { _this2.compiled = true; } else { $global.console.log("link failed: " + _this2.gl.getProgramInfoLog(_this2.pg)); } this.defaultShaderTexture = new pot_graphics_Shader(this.gl); let _this3 = this.defaultShaderTexture; _this3.vSource = vertexSource; _this3.compiled = false; let _this4 = this.defaultShaderTexture; _this4.fSource = "\n\t\t\tprecision mediump float;\n\t\t\tuniform sampler2D texture;\n\n\t\t\tvarying vec4 vColor;\n\t\t\tvarying vec3 vPosition;\n\t\t\tvarying vec3 vNormal;\n\t\t\tvarying vec2 vTexCoord;\n\t\t\tuniform float ambient;\n\t\t\tuniform float diffuse;\n\t\t\tuniform float specular;\n\t\t\tuniform float shininess;\n\t\t\tuniform float emission;\n\t\t\tuniform int numLights;\n\t\t\tuniform vec4 lightPositions[8];\n\t\t\tuniform vec3 lightColors[8];\n\t\t\tuniform vec3 lightNormals[8];\n\t\t\t\n\t\t\tvec3 safeNormalize(vec3 v) {\n\t\t\t\treturn dot(v, v) > 0.0 ? normalize(v) : vec3(0);\n\t\t\t}\n\n\t\t\tvoid main() {\n\t\t\t\tvec4 texMulColor = texture2D(texture, vTexCoord) * vColor;\n\t\t\t\tif (numLights == 0) {\n\t\t\t\t\tgl_FragColor = texMulColor;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvec3 eye = safeNormalize(vPosition);\n\t\t\t\tvec3 n = safeNormalize(vNormal);\n\t\t\t\tvec3 color = texMulColor.xyz;\n\t\t\t\tvec3 ambientTotal = vec3(0);\n\t\t\t\tvec3 diffuseTotal = vec3(0);\n\t\t\t\tvec3 specularTotal = vec3(0);\n\t\t\t\tvec3 emissionTotal = color * emission;\n\n\t\t\t\tif (!gl_FrontFacing) n = -n;\n\n\t\t\t\tfor (int i = 0; i < 8; i++) {\n\t\t\t\t\tif (i == numLights) break;\n\t\t\t\t\tvec4 lp = lightPositions[i];\n\t\t\t\t\tvec3 lc = lightColors[i];\n\t\t\t\t\tvec3 ln = lightNormals[i];\n\t\t\t\t\tbool amb = lp.w == 0.0 && dot(ln, ln) == 0.0;\n\t\t\t\t\tbool dir = lp.w == 0.0;\n\t\t\t\t\tif (amb) {\n\t\t\t\t\t\tambientTotal += lc * color * ambient;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (!dir) {\n\t\t\t\t\t\t\tln = safeNormalize(vPosition - lp.xyz);\n\t\t\t\t\t\t\t// TODO: spot light\n\t\t\t\t\t\t}\n\t\t\t\t\t\tfloat ldot = -dot(ln, n);\n\t\t\t\t\t\tif (ldot < 0.0) ldot = 0.0;\n\t\t\t\t\t\tdiffuseTotal += lc * color * ldot * diffuse;\n\t\t\t\t\t\tif (ldot > 0.0) {\n\t\t\t\t\t\t\tvec3 reflEye = eye - 2.0 * n * dot(eye, n);\n\t\t\t\t\t\t\tfloat rdot = -dot(reflEye, ln);\n\t\t\t\t\t\t\tif (rdot < 0.0) rdot = 0.0;\n\t\t\t\t\t\t\tspecularTotal += lc * pow(rdot, shininess) * specular;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tgl_FragColor = vec4(ambientTotal + diffuseTotal + specularTotal + emissionTotal, texMulColor.w);\n\t\t\t}\n\t\t"; _this4.compiled = false; let _this5 = this.defaultShaderTexture; _this5.map = new haxe_ds_StringMap(); _this5.gl.shaderSource(_this5.vs,_this5.vSource); _this5.gl.compileShader(_this5.vs); if(!_this5.gl.getShaderParameter(_this5.vs,35713)) { let v = _this5.gl.getShaderInfoLog(_this5.vs) + "\nsource:\n" + _this5.vSource; window.alert(Std.string(v)); } _this5.gl.shaderSource(_this5.fs,_this5.fSource); _this5.gl.compileShader(_this5.fs); if(!_this5.gl.getShaderParameter(_this5.fs,35713)) { let v = _this5.gl.getShaderInfoLog(_this5.fs) + "\nsource:\n" + _this5.fSource; window.alert(Std.string(v)); } _this5.gl.attachShader(_this5.pg,_this5.vs); _this5.gl.attachShader(_this5.pg,_this5.fs); _this5.gl.linkProgram(_this5.pg); if(_this5.gl.getProgramParameter(_this5.pg,35714)) { _this5.compiled = true; } else { $global.console.log("link failed: " + _this5.gl.getProgramInfoLog(_this5.pg)); } this.currentShader = null; } initBuffers() { this.positionBuf = new pot_graphics_VertexBuffer(this.gl,"position",3); this.colorBuf = new pot_graphics_VertexBuffer(this.gl,"color",4); this.normalBuf = new pot_graphics_VertexBuffer(this.gl,"normal",3); this.texCoordBuf = new pot_graphics_VertexBuffer(this.gl,"texCoord",2); this.indexBuf = new pot_graphics_IndexBuffer(this.gl); } chooseShader() { if(this.currentShader != null) { return this.currentShader; } if(this.currentTexture != null) { return this.defaultShaderTexture; } return this.defaultShader; } beginScene() { if(this.sceneOpen != false) { throw new Error("scene already begun"); } this.sceneOpen = true; this.modelMat.identity(); this.numLights = 0; this.currentTexture = null; this.colorR = 1; this.colorG = 1; this.colorB = 1; this.colorA = 1; this.normalX = 0; this.normalY = 0; this.normalZ = 0; this.texCoordU = 0; this.texCoordV = 0; this.materialAmb = 1; this.materialDif = 1; this.materialSpc = 0; this.materialShn = 10; this.materialEmi = 0; if(!this.cameraSet) { this.defaultCameraPosX = this.screenWidth * 0.5; this.defaultCameraPosY = this.screenHeight * 0.5; this.defaultCameraPosZ = -this.screenHeight / (2 * Math.tan(this.cameraFov * 0.5)); this.viewMat.lookAt(this.defaultCameraPosX,this.defaultCameraPosY,this.defaultCameraPosZ,this.defaultCameraPosX,this.defaultCameraPosY,0,0,-1,0); } } pushMatrix() { if(this.matStackCount > 1008) { throw new Error("matrix stack overflowed"); } let val = this.modelMat.array[0]; this.matStack[this.matStackCount++] = val; let val1 = this.modelMat.array[1]; this.matStack[this.matStackCount++] = val1; let val2 = this.modelMat.array[2]; this.matStack[this.matStackCount++] = val2; let val3 = this.modelMat.array[3]; this.matStack[this.matStackCount++] = val3; let val4 = this.modelMat.array[4]; this.matStack[this.matStackCount++] = val4; let val5 = this.modelMat.array[5]; this.matStack[this.matStackCount++] = val5; let val6 = this.modelMat.array[6]; this.matStack[this.matStackCount++] = val6; let val7 = this.modelMat.array[7]; this.matStack[this.matStackCount++] = val7; let val8 = this.modelMat.array[8]; this.matStack[this.matStackCount++] = val8; let val9 = this.modelMat.array[9]; this.matStack[this.matStackCount++] = val9; let val10 = this.modelMat.array[10]; this.matStack[this.matStackCount++] = val10; let val11 = this.modelMat.array[11]; this.matStack[this.matStackCount++] = val11; let val12 = this.modelMat.array[12]; this.matStack[this.matStackCount++] = val12; let val13 = this.modelMat.array[13]; this.matStack[this.matStackCount++] = val13; let val14 = this.modelMat.array[14]; this.matStack[this.matStackCount++] = val14; let val15 = this.modelMat.array[15]; this.matStack[this.matStackCount++] = val15; } popMatrix() { if(this.matStackCount < 16) { throw new Error("cannot pop matrix"); } this.modelMat.array[15] = this.matStack[--this.matStackCount]; this.modelMat.array[14] = this.matStack[--this.matStackCount]; this.modelMat.array[13] = this.matStack[--this.matStackCount]; this.modelMat.array[12] = this.matStack[--this.matStackCount]; this.modelMat.array[11] = this.matStack[--this.matStackCount]; this.modelMat.array[10] = this.matStack[--this.matStackCount]; this.modelMat.array[9] = this.matStack[--this.matStackCount]; this.modelMat.array[8] = this.matStack[--this.matStackCount]; this.modelMat.array[7] = this.matStack[--this.matStackCount]; this.modelMat.array[6] = this.matStack[--this.matStackCount]; this.modelMat.array[5] = this.matStack[--this.matStackCount]; this.modelMat.array[4] = this.matStack[--this.matStackCount]; this.modelMat.array[3] = this.matStack[--this.matStackCount]; this.modelMat.array[2] = this.matStack[--this.matStackCount]; this.modelMat.array[1] = this.matStack[--this.matStackCount]; this.modelMat.array[0] = this.matStack[--this.matStackCount]; } beginShape(mode) { if(this.sceneOpen != true) { throw new Error("begin scene before begin shape"); } this.shapeMode = mode; this.numVertices = 0; this.positionBuf.length = 0; this.colorBuf.length = 0; this.normalBuf.length = 0; this.texCoordBuf.length = 0; this.indexBuf.length = 0; } box(width,height,depth) { let tmpTexMode = this.texMode; this.texMode = 1; this.beginShape(4); width *= 0.5; height *= 0.5; depth *= 0.5; let x1 = -width; let x2 = width; let y1 = -height; let y2 = height; let z1 = -depth; let z2 = depth; if(this.currentTexture != null) { this.normalX = -1; this.normalY = 0; this.normalZ = 0; let u = 0; let v = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u *= this.currentTexture.imageToU; v *= this.currentTexture.imageToV; break; case 1: u *= this.currentTexture.normalToU; v *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u; this.texCoordV = 1 - v; this.vertex(x1,y1,z1); let u1 = 0; let v1 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u1 *= this.currentTexture.imageToU; v1 *= this.currentTexture.imageToV; break; case 1: u1 *= this.currentTexture.normalToU; v1 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u1; this.texCoordV = 1 - v1; this.vertex(x1,y1,z2); let u2 = 1; let v2 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u2 *= this.currentTexture.imageToU; v2 *= this.currentTexture.imageToV; break; case 1: u2 *= this.currentTexture.normalToU; v2 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u2; this.texCoordV = 1 - v2; this.vertex(x1,y2,z2); let u3 = 0; let v3 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u3 *= this.currentTexture.imageToU; v3 *= this.currentTexture.imageToV; break; case 1: u3 *= this.currentTexture.normalToU; v3 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u3; this.texCoordV = 1 - v3; this.vertex(x1,y1,z1); let u4 = 1; let v4 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u4 *= this.currentTexture.imageToU; v4 *= this.currentTexture.imageToV; break; case 1: u4 *= this.currentTexture.normalToU; v4 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u4; this.texCoordV = 1 - v4; this.vertex(x1,y2,z2); let u5 = 1; let v5 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u5 *= this.currentTexture.imageToU; v5 *= this.currentTexture.imageToV; break; case 1: u5 *= this.currentTexture.normalToU; v5 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u5; this.texCoordV = 1 - v5; this.vertex(x1,y2,z1); this.normalX = 1; this.normalY = 0; this.normalZ = 0; let u6 = 0; let v6 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u6 *= this.currentTexture.imageToU; v6 *= this.currentTexture.imageToV; break; case 1: u6 *= this.currentTexture.normalToU; v6 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u6; this.texCoordV = 1 - v6; this.vertex(x2,y1,z1); let u7 = 0; let v7 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u7 *= this.currentTexture.imageToU; v7 *= this.currentTexture.imageToV; break; case 1: u7 *= this.currentTexture.normalToU; v7 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u7; this.texCoordV = 1 - v7; this.vertex(x2,y2,z1); let u8 = 1; let v8 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u8 *= this.currentTexture.imageToU; v8 *= this.currentTexture.imageToV; break; case 1: u8 *= this.currentTexture.normalToU; v8 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u8; this.texCoordV = 1 - v8; this.vertex(x2,y2,z2); let u9 = 0; let v9 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u9 *= this.currentTexture.imageToU; v9 *= this.currentTexture.imageToV; break; case 1: u9 *= this.currentTexture.normalToU; v9 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u9; this.texCoordV = 1 - v9; this.vertex(x2,y1,z1); let u10 = 1; let v10 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u10 *= this.currentTexture.imageToU; v10 *= this.currentTexture.imageToV; break; case 1: u10 *= this.currentTexture.normalToU; v10 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u10; this.texCoordV = 1 - v10; this.vertex(x2,y2,z2); let u11 = 1; let v11 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u11 *= this.currentTexture.imageToU; v11 *= this.currentTexture.imageToV; break; case 1: u11 *= this.currentTexture.normalToU; v11 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u11; this.texCoordV = 1 - v11; this.vertex(x2,y1,z2); this.normalX = 0; this.normalY = -1; this.normalZ = 0; let u12 = 0; let v12 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u12 *= this.currentTexture.imageToU; v12 *= this.currentTexture.imageToV; break; case 1: u12 *= this.currentTexture.normalToU; v12 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u12; this.texCoordV = 1 - v12; this.vertex(x1,y1,z1); let u13 = 0; let v13 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u13 *= this.currentTexture.imageToU; v13 *= this.currentTexture.imageToV; break; case 1: u13 *= this.currentTexture.normalToU; v13 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u13; this.texCoordV = 1 - v13; this.vertex(x2,y1,z1); let u14 = 1; let v14 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u14 *= this.currentTexture.imageToU; v14 *= this.currentTexture.imageToV; break; case 1: u14 *= this.currentTexture.normalToU; v14 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u14; this.texCoordV = 1 - v14; this.vertex(x2,y1,z2); let u15 = 0; let v15 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u15 *= this.currentTexture.imageToU; v15 *= this.currentTexture.imageToV; break; case 1: u15 *= this.currentTexture.normalToU; v15 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u15; this.texCoordV = 1 - v15; this.vertex(x1,y1,z1); let u16 = 1; let v16 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u16 *= this.currentTexture.imageToU; v16 *= this.currentTexture.imageToV; break; case 1: u16 *= this.currentTexture.normalToU; v16 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u16; this.texCoordV = 1 - v16; this.vertex(x2,y1,z2); let u17 = 1; let v17 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u17 *= this.currentTexture.imageToU; v17 *= this.currentTexture.imageToV; break; case 1: u17 *= this.currentTexture.normalToU; v17 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u17; this.texCoordV = 1 - v17; this.vertex(x1,y1,z2); this.normalX = 0; this.normalY = 1; this.normalZ = 0; let u18 = 0; let v18 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u18 *= this.currentTexture.imageToU; v18 *= this.currentTexture.imageToV; break; case 1: u18 *= this.currentTexture.normalToU; v18 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u18; this.texCoordV = 1 - v18; this.vertex(x1,y2,z1); let u19 = 0; let v19 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u19 *= this.currentTexture.imageToU; v19 *= this.currentTexture.imageToV; break; case 1: u19 *= this.currentTexture.normalToU; v19 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u19; this.texCoordV = 1 - v19; this.vertex(x1,y2,z2); let u20 = 1; let v20 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u20 *= this.currentTexture.imageToU; v20 *= this.currentTexture.imageToV; break; case 1: u20 *= this.currentTexture.normalToU; v20 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u20; this.texCoordV = 1 - v20; this.vertex(x2,y2,z2); let u21 = 0; let v21 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u21 *= this.currentTexture.imageToU; v21 *= this.currentTexture.imageToV; break; case 1: u21 *= this.currentTexture.normalToU; v21 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u21; this.texCoordV = 1 - v21; this.vertex(x1,y2,z1); let u22 = 1; let v22 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u22 *= this.currentTexture.imageToU; v22 *= this.currentTexture.imageToV; break; case 1: u22 *= this.currentTexture.normalToU; v22 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u22; this.texCoordV = 1 - v22; this.vertex(x2,y2,z2); let u23 = 1; let v23 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u23 *= this.currentTexture.imageToU; v23 *= this.currentTexture.imageToV; break; case 1: u23 *= this.currentTexture.normalToU; v23 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u23; this.texCoordV = 1 - v23; this.vertex(x2,y2,z1); this.normalX = 0; this.normalY = 0; this.normalZ = -1; let u24 = 0; let v24 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u24 *= this.currentTexture.imageToU; v24 *= this.currentTexture.imageToV; break; case 1: u24 *= this.currentTexture.normalToU; v24 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u24; this.texCoordV = 1 - v24; this.vertex(x1,y1,z1); let u25 = 0; let v25 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u25 *= this.currentTexture.imageToU; v25 *= this.currentTexture.imageToV; break; case 1: u25 *= this.currentTexture.normalToU; v25 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u25; this.texCoordV = 1 - v25; this.vertex(x1,y2,z1); let u26 = 1; let v26 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u26 *= this.currentTexture.imageToU; v26 *= this.currentTexture.imageToV; break; case 1: u26 *= this.currentTexture.normalToU; v26 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u26; this.texCoordV = 1 - v26; this.vertex(x2,y2,z1); let u27 = 0; let v27 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u27 *= this.currentTexture.imageToU; v27 *= this.currentTexture.imageToV; break; case 1: u27 *= this.currentTexture.normalToU; v27 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u27; this.texCoordV = 1 - v27; this.vertex(x1,y1,z1); let u28 = 1; let v28 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u28 *= this.currentTexture.imageToU; v28 *= this.currentTexture.imageToV; break; case 1: u28 *= this.currentTexture.normalToU; v28 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u28; this.texCoordV = 1 - v28; this.vertex(x2,y2,z1); let u29 = 1; let v29 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u29 *= this.currentTexture.imageToU; v29 *= this.currentTexture.imageToV; break; case 1: u29 *= this.currentTexture.normalToU; v29 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u29; this.texCoordV = 1 - v29; this.vertex(x2,y1,z1); this.normalX = 0; this.normalY = 0; this.normalZ = 1; let u30 = 0; let v30 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u30 *= this.currentTexture.imageToU; v30 *= this.currentTexture.imageToV; break; case 1: u30 *= this.currentTexture.normalToU; v30 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u30; this.texCoordV = 1 - v30; this.vertex(x1,y1,z2); let u31 = 0; let v31 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u31 *= this.currentTexture.imageToU; v31 *= this.currentTexture.imageToV; break; case 1: u31 *= this.currentTexture.normalToU; v31 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u31; this.texCoordV = 1 - v31; this.vertex(x2,y1,z2); let u32 = 1; let v32 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u32 *= this.currentTexture.imageToU; v32 *= this.currentTexture.imageToV; break; case 1: u32 *= this.currentTexture.normalToU; v32 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u32; this.texCoordV = 1 - v32; this.vertex(x2,y2,z2); let u33 = 0; let v33 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u33 *= this.currentTexture.imageToU; v33 *= this.currentTexture.imageToV; break; case 1: u33 *= this.currentTexture.normalToU; v33 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u33; this.texCoordV = 1 - v33; this.vertex(x1,y1,z2); let u34 = 1; let v34 = 1; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u34 *= this.currentTexture.imageToU; v34 *= this.currentTexture.imageToV; break; case 1: u34 *= this.currentTexture.normalToU; v34 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u34; this.texCoordV = 1 - v34; this.vertex(x2,y2,z2); let u35 = 1; let v35 = 0; if(this.texMode != 2 && this.currentTexture == null) { throw new Error("set texture before calling texCoord when texture mode is not Raw"); } switch(this.texMode) { case 0: u35 *= this.currentTexture.imageToU; v35 *= this.currentTexture.imageToV; break; case 1: u35 *= this.currentTexture.normalToU; v35 *= this.currentTexture.normalToV; break; case 2: break; } this.texCoordU = u35; this.texCoordV = 1 - v35; this.vertex(x1,y2,z2); } else { this.normalX = -1; this.normalY = 0; this.normalZ = 0; this.vertex(x1,y1,z1); this.vertex(x1,y1,z2); this.vertex(x1,y2,z2); this.vertex(x1,y1,z1); this.vertex(x1,y2,z2); this.vertex(x1,y2,z1); this.normalX = 1; this.normalY = 0; this.normalZ = 0; this.vertex(x2,y1,z1); this.vertex(x2,y2,z1); this.vertex(x2,y2,z2); this.vertex(x2,y1,z1); this.vertex(x2,y2,z2); this.vertex(x2,y1,z2); this.normalX = 0; this.normalY = -1; this.normalZ = 0; this.vertex(x1,y1,z1); this.vertex(x2,y1,z1); this.vertex(x2,y1,z2); this.vertex(x1,y1,z1); this.vertex(x2,y1,z2); this.vertex(x1,y1,z2); this.normalX = 0; this.normalY = 1; this.normalZ = 0; this.vertex(x1,y2,z1); this.vertex(x1,y2,z2); this.vertex(x2,y2,z2); this.vertex(x1,y2,z1); this.vertex(x2,y2,z2); this.vertex(x2,y2,z1); this.normalX = 0; this.normalY = 0; this.normalZ = -1; this.vertex(x1,y1,z1); this.vertex(x1,y2,z1); this.vertex(x2,y2,z1); this.vertex(x1,y1,z1); this.vertex(x2,y2,z1); this.vertex(x2,y1,z1); this.normalX = 0; this.normalY = 0; this.normalZ = 1; this.vertex(x1,y1,z2); this.vertex(x2,y1,z2); this.vertex(x2,y2,z2); this.vertex(x1,y1,z2); this.vertex(x2,y2,z2); this.vertex(x1,y2,z2); } this.endShape(); this.texMode = tmpTexMode; } vertex(x,y,z) { if(z == null) { z = 0; } let _this = this.indexBuf; let i = this.numVertices++; if(_this.length == _this.array.length) { let oldLength = _this.array.length; let newArray = new Int32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this.array[i]; } _this.array = newArray; } _this.array[_this.length++] = i; let _this1 = this.positionBuf; if(_this1.length == _this1.array.length) { let oldLength = _this1.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this1.array[i]; } _this1.array = newArray; } _this1.array[_this1.length++] = x; let _this2 = this.positionBuf; if(_this2.length == _this2.array.length) { let oldLength = _this2.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this2.array[i]; } _this2.array = newArray; } _this2.array[_this2.length++] = y; let _this3 = this.positionBuf; if(_this3.length == _this3.array.length) { let oldLength = _this3.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this3.array[i]; } _this3.array = newArray; } _this3.array[_this3.length++] = z; let _this4 = this.colorBuf; let f = this.colorR; if(_this4.length == _this4.array.length) { let oldLength = _this4.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this4.array[i]; } _this4.array = newArray; } _this4.array[_this4.length++] = f; let _this5 = this.colorBuf; let f1 = this.colorG; if(_this5.length == _this5.array.length) { let oldLength = _this5.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this5.array[i]; } _this5.array = newArray; } _this5.array[_this5.length++] = f1; let _this6 = this.colorBuf; let f2 = this.colorB; if(_this6.length == _this6.array.length) { let oldLength = _this6.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this6.array[i]; } _this6.array = newArray; } _this6.array[_this6.length++] = f2; let _this7 = this.colorBuf; let f3 = this.colorA; if(_this7.length == _this7.array.length) { let oldLength = _this7.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this7.array[i]; } _this7.array = newArray; } _this7.array[_this7.length++] = f3; let _this8 = this.normalBuf; let f4 = this.normalX; if(_this8.length == _this8.array.length) { let oldLength = _this8.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this8.array[i]; } _this8.array = newArray; } _this8.array[_this8.length++] = f4; let _this9 = this.normalBuf; let f5 = this.normalY; if(_this9.length == _this9.array.length) { let oldLength = _this9.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this9.array[i]; } _this9.array = newArray; } _this9.array[_this9.length++] = f5; let _this10 = this.normalBuf; let f6 = this.normalZ; if(_this10.length == _this10.array.length) { let oldLength = _this10.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this10.array[i]; } _this10.array = newArray; } _this10.array[_this10.length++] = f6; let _this11 = this.texCoordBuf; let f7 = this.texCoordU; if(_this11.length == _this11.array.length) { let oldLength = _this11.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this11.array[i]; } _this11.array = newArray; } _this11.array[_this11.length++] = f7; let _this12 = this.texCoordBuf; let f8 = this.texCoordV; if(_this12.length == _this12.array.length) { let oldLength = _this12.array.length; let newArray = new Float32Array(oldLength << 1); let _g = 0; while(_g < oldLength) { let i = _g++; newArray[i] = _this12.array[i]; } _this12.array = newArray; } _this12.array[_this12.length++] = f8; } endShape() { let shader = this.chooseShader(); let pg = shader.pg; this.modelviewMat.mul(this.viewMat,this.modelMat); this.normalMat.inverse(this.modelviewMat); this.normalMat.transpose(this.normalMat); let tmp; if(Object.prototype.hasOwnProperty.call(shader.map.h,"model")) { tmp = shader.map.h["model"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"model"); shader.map.h["model"] = ul; tmp = ul; } if(tmp != null) { shader.setMatrix("model",this.modelMat.array); } let tmp1; if(Object.prototype.hasOwnProperty.call(shader.map.h,"view")) { tmp1 = shader.map.h["view"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"view"); shader.map.h["view"] = ul; tmp1 = ul; } if(tmp1 != null) { shader.setMatrix("view",this.viewMat.array); } let tmp2; if(Object.prototype.hasOwnProperty.call(shader.map.h,"projection")) { tmp2 = shader.map.h["projection"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"projection"); shader.map.h["projection"] = ul; tmp2 = ul; } if(tmp2 != null) { shader.setMatrix("projection",this.projMat.array); } let tmp3; if(Object.prototype.hasOwnProperty.call(shader.map.h,"transform")) { tmp3 = shader.map.h["transform"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"transform"); shader.map.h["transform"] = ul; tmp3 = ul; } if(tmp3 != null) { this.mvpMat.mul(this.projMat,this.modelviewMat); shader.setMatrix("transform",this.mvpMat.array); } let tmp4; if(Object.prototype.hasOwnProperty.call(shader.map.h,"modelview")) { tmp4 = shader.map.h["modelview"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"modelview"); shader.map.h["modelview"] = ul; tmp4 = ul; } if(tmp4 != null) { shader.setMatrix("modelview",this.modelviewMat.array); } let tmp5; if(Object.prototype.hasOwnProperty.call(shader.map.h,"normalMatrix")) { tmp5 = shader.map.h["normalMatrix"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"normalMatrix"); shader.map.h["normalMatrix"] = ul; tmp5 = ul; } if(tmp5 != null) { this.normalMat.toMat3(); shader.setMatrix("normalMatrix",this.normalMat.array3); } if(this.currentTexture != null) { shader.setTexture("texture",this.currentTexture); let tmp; if(Object.prototype.hasOwnProperty.call(shader.map.h,"texResolution")) { tmp = shader.map.h["texResolution"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"texResolution"); shader.map.h["texResolution"] = ul; tmp = ul; } if(tmp != null) { shader.setFloat("texResolution",this.currentTexture.textureWidth,this.currentTexture.textureHeight); } let tmp1; if(Object.prototype.hasOwnProperty.call(shader.map.h,"texViewport")) { tmp1 = shader.map.h["texViewport"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"texViewport"); shader.map.h["texViewport"] = ul; tmp1 = ul; } if(tmp1 != null) { shader.setFloat("texViewport",0,1 - this.currentTexture.height / this.currentTexture.textureHeight,this.currentTexture.width / this.currentTexture.textureWidth,this.currentTexture.height / this.currentTexture.textureHeight); } } let tmp6; if(Object.prototype.hasOwnProperty.call(shader.map.h,"ambient")) { tmp6 = shader.map.h["ambient"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"ambient"); shader.map.h["ambient"] = ul; tmp6 = ul; } if(tmp6 != null) { shader.setFloat("ambient",this.materialAmb); } let tmp7; if(Object.prototype.hasOwnProperty.call(shader.map.h,"diffuse")) { tmp7 = shader.map.h["diffuse"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"diffuse"); shader.map.h["diffuse"] = ul; tmp7 = ul; } if(tmp7 != null) { shader.setFloat("diffuse",this.materialDif); } let tmp8; if(Object.prototype.hasOwnProperty.call(shader.map.h,"specular")) { tmp8 = shader.map.h["specular"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"specular"); shader.map.h["specular"] = ul; tmp8 = ul; } if(tmp8 != null) { shader.setFloat("specular",this.materialSpc); } let tmp9; if(Object.prototype.hasOwnProperty.call(shader.map.h,"shininess")) { tmp9 = shader.map.h["shininess"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"shininess"); shader.map.h["shininess"] = ul; tmp9 = ul; } if(tmp9 != null) { shader.setFloat("shininess",this.materialShn); } let tmp10; if(Object.prototype.hasOwnProperty.call(shader.map.h,"emission")) { tmp10 = shader.map.h["emission"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"emission"); shader.map.h["emission"] = ul; tmp10 = ul; } if(tmp10 != null) { shader.setFloat("emission",this.materialEmi); } let tmp11; if(Object.prototype.hasOwnProperty.call(shader.map.h,"numLights")) { tmp11 = shader.map.h["numLights"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"numLights"); shader.map.h["numLights"] = ul; tmp11 = ul; } if(tmp11 != null) { shader.setInt("numLights",this.numLights); } let tmp12; if(Object.prototype.hasOwnProperty.call(shader.map.h,"lightPositions")) { tmp12 = shader.map.h["lightPositions"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"lightPositions"); shader.map.h["lightPositions"] = ul; tmp12 = ul; } if(tmp12 != null) { let _g = 0; let _g1 = this.numLights; while(_g < _g1) { let i = _g++; let light = this.lightBuf[i]; shader.setFloat("lightPositions[" + i + "]",light.posX * this.viewMat.array[0] + light.posY * this.viewMat.array[4] + light.posZ * this.viewMat.array[8] + this.viewMat.array[12],light.posX * this.viewMat.array[1] + light.posY * this.viewMat.array[5] + light.posZ * this.viewMat.array[9] + this.viewMat.array[13],light.posX * this.viewMat.array[2] + light.posY * this.viewMat.array[6] + light.posZ * this.viewMat.array[10] + this.viewMat.array[14],light.posW); } } let tmp13; if(Object.prototype.hasOwnProperty.call(shader.map.h,"lightNormals")) { tmp13 = shader.map.h["lightNormals"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"lightNormals"); shader.map.h["lightNormals"] = ul; tmp13 = ul; } if(tmp13 != null) { let _g = 0; let _g1 = this.numLights; while(_g < _g1) { let i = _g++; let light = this.lightBuf[i]; shader.setFloat("lightNormals[" + i + "]",light.norX * this.viewMat.array[0] + light.norY * this.viewMat.array[4] + light.norZ * this.viewMat.array[8],light.norX * this.viewMat.array[1] + light.norY * this.viewMat.array[5] + light.norZ * this.viewMat.array[9],light.norX * this.viewMat.array[2] + light.norY * this.viewMat.array[6] + light.norZ * this.viewMat.array[10]); } } let tmp14; if(Object.prototype.hasOwnProperty.call(shader.map.h,"lightColors")) { tmp14 = shader.map.h["lightColors"]; } else { let ul = shader.gl.getUniformLocation(shader.pg,"lightColors"); shader.map.h["lightColors"] = ul; tmp14 = ul; } if(tmp14 != null) { let _g = 0; let _g1 = this.numLights; while(_g < _g1) { let i = _g++; let light = this.lightBuf[i]; shader.setFloat("lightColors[" + i + "]",light.r,light.g,light.b); } } let _this = this.indexBuf; _this.gl.bindBuffer(34963,_this.buffer); _this.gl.bufferData(34963,new Int32Array(_this.array.buffer,0,_this.length),35048); _this.gl.bindBuffer(34963,null); let _this1 = this.positionBuf; _this1.gl.bindBuffer(34962,_this1.buffer); _this1.gl.bufferData(34962,new Float32Array(_this1.array.buffer,0,_this1.length),35048); _this1.gl.bindBuffer(34962,null); let _this2 = this.colorBuf; _this2.gl.bindBuffer(34962,_this2.buffer); _this2.gl.bufferData(34962,new Float32Array(_this2.array.buffer,0,_this2.length),35048); _this2.gl.bindBuffer(34962,null); let _this3 = this.normalBuf; _this3.gl.bindBuffer(34962,_this3.buffer); _this3.gl.bufferData(34962,new Float32Array(_this3.array.buffer,0,_this3.length),35048); _this3.gl.bindBuffer(34962,null); let _this4 = this.texCoordBuf; _this4.gl.bindBuffer(34962,_this4.buffer); _this4.gl.bufferData(34962,new Float32Array(_this4.array.buffer,0,_this4.length),35048); _this4.gl.bindBuffer(34962,null); let _this5 = this.positionBuf; let idx = _this5.gl.getAttribLocation(pg,_this5.name); if(idx != -1) { _this5.gl.bindBuffer(34962,_this5.buffer); _this5.gl.enableVertexAttribArray(idx); _this5.gl.vertexAttribPointer(idx,_this5.size,5126,false,0,0); _this5.gl.bindBuffer(34962,null); } let _this6 = this.colorBuf; let idx1 = _this6.gl.getAttribLocation(pg,_this6.name); if(idx1 != -1) { _this6.gl.bindBuffer(34962,_this6.buffer); _this6.gl.enableVertexAttribArray(idx1); _this6.gl.vertexAttribPointer(idx1,_this6.size,5126,false,0,0); _this6.gl.bindBuffer(34962,null); } let _this7 = this.normalBuf; let idx2 = _this7.gl.getAttribLocation(pg,_this7.name); if(idx2 != -1) { _this7.gl.bindBuffer(34962,_this7.buffer); _this7.gl.enableVertexAttribArray(idx2); _this7.gl.vertexAttribPointer(idx2,_this7.size,5126,false,0,0); _this7.gl.bindBuffer(34962,null); } let _this8 = this.texCoordBuf; let idx3 = _this8.gl.getAttribLocation(pg,_this8.name); if(idx3 != -1) { _this8.gl.bindBuffer(34962,_this8.buffer); _this8.gl.enableVertexAttribArray(idx3); _this8.gl.vertexAttribPointer(idx3,_this8.size,5126,false,0,0); _this8.gl.bindBuffer(34962,null); } if(!shader.compiled) { throw new Error("shader is not compiled"); } shader.gl.useProgram(shader.pg); let texUnit = 0; let name_keys = Object.keys(shader.uniforms.h); let name_length = name_keys.length; let name_current = 0; while(name_current < name_length) { let name = name_keys[name_current++]; let tmp; if(Object.prototype.hasOwnProperty.call(shader.map.h,name)) { tmp = shader.map.h[name]; } else { let ul = shader.gl.getUniformLocation(shader.pg,name); shader.map.h[name] = ul; tmp = ul; } if(tmp == null) { continue; } let uniform = shader.uniforms.h[name]; let loc; if(Object.prototype.hasOwnProperty.call(shader.map.h,name)) { loc = shader.map.h[name]; } else { let ul = shader.gl.getUniformLocation(shader.pg,name); shader.map.h[name] = ul; loc = ul; } switch(uniform.type) { case 0: shader.gl.uniform1i(loc,uniform.i1); break; case 1: shader.gl.uniform2i(loc,uniform.i1,uniform.i2); break; case 2: shader.gl.uniform3i(loc,uniform.i1,uniform.i2,uniform.i3); break; case 3: shader.gl.uniform4i(loc,uniform.i1,uniform.i2,uniform.i3,uniform.i4); break; case 4: shader.gl.uniform1f(loc,uniform.f1); break; case 5: shader.gl.uniform2f(loc,uniform.f1,uniform.f2); break; case 6: shader.gl.uniform3f(loc,uniform.f1,uniform.f2,uniform.f3); break; case 7: shader.gl.uniform4f(loc,uniform.f1,uniform.f2,uniform.f3,uniform.f4); break; case 8: shader.gl.uniformMatrix2fv(loc,false,uniform.m2); break; case 9: shader.gl.uniformMatrix3fv(loc,false,uniform.m3); break; case 10: shader.gl.uniformMatrix4fv(loc,false,uniform.m4); break; case 11: shader.gl.activeTexture(33984 + texUnit); shader.gl.bindTexture(3553,uniform.tex == null ? null : uniform.tex.texture); shader.gl.uniform1i(loc,texUnit); ++texUnit; break; } } shader.gl.activeTexture(33984); let _this9 = this.indexBuf; let mode = this.shapeMode; _this9.gl.bindBuffer(34963,_this9.buffer); _this9.gl.drawElements(mode,_this9.length,5125,0); _this9.gl.bindBuffer(34963,null); } } pot_graphics_Graphics.__name__ = true; class pot_graphics__$Graphics_Light { constructor() { } } pot_graphics__$Graphics_Light.__name__ = true; class pot_graphics__$Graphics_UniformMatrix { constructor() { let _g = []; _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); _g.push(0); this.array = _g; let _g1 = []; _g1.push(0); _g1.push(0); _g1.push(0); _g1.push(0); _g1.push(0); _g1.push(0); _g1.push(0); _g1.push(0); _g1.push(0); this.array3 = _g1; } identity() { this.array[0] = 1; this.array[1] = 0; this.array[2] = 0; this.array[3] = 0; this.array[4] = 0; this.array[5] = 1; this.array[6] = 0; this.array[7] = 0; this.array[8] = 0; this.array[9] = 0; this.array[10] = 1; this.array[11] = 0; this.array[12] = 0; this.array[13] = 0; this.array[14] = 0; this.array[15] = 1; } lookAt(eyeX,eyeY,eyeZ,atX,atY,atZ,upX,upY,upZ) { let zx = eyeX - atX; let zy = eyeY - atY; let zz = eyeZ - atZ; let tmp = 1 / Math.sqrt(zx * zx + zy * zy + zz * zz); zx *= tmp; zy *= tmp; zz *= tmp; let xx = upY * zz - upZ * zy; let xy = upZ * zx - upX * zz; let xz = upX * zy - upY * zx; tmp = 1 / Math.sqrt(xx * xx + xy * xy + xz * xz); xx *= tmp; xy *= tmp; xz *= tmp; let yx = zy * xz - zz * xy; let yy = zz * xx - zx * xz; let yz = zx * xy - zy * xx; this.array[0] = xx; this.array[1] = yx; this.array[2] = zx; this.array[3] = 0; this.array[4] = xy; this.array[5] = yy; this.array[6] = zy; this.array[7] = 0; this.array[8] = xz; this.array[9] = yz; this.array[10] = zz; this.array[11] = 0; this.array[12] = -(xx * eyeX + xy * eyeY + xz * eyeZ); this.array[13] = -(yx * eyeX + yy * eyeY + yz * eyeZ); this.array[14] = -(zx * eyeX + zy * eyeY + zz * eyeZ); this.array[15] = 1; } perspective(fovY,aspect,near,far) { let h = 1 / Math.tan(fovY * 0.5); let fnf = far / (near - far); this.array[0] = h / aspect; this.array[1] = 0; this.array[2] = 0; this.array[3] = 0; this.array[4] = 0; this.array[5] = h; this.array[6] = 0; this.array[7] = 0; this.array[8] = 0; this.array[9] = 0; this.array[10] = fnf; this.array[11] = -1; this.array[12] = 0; this.array[13] = 0; this.array[14] = near * fnf; this.array[15] = 0; } appendScale(sx,sy,sz) { this.array[0] *= sx; this.array[1] *= sx; this.array[2] *= sx; this.array[3] *= sx; this.array[4] *= sy; this.array[5] *= sy; this.array[6] *= sy; this.array[7] *= sy; this.array[8] *= sz; this.array[9] *= sz; this.array[10] *= sz; this.array[11] *= sz; } appendTransform(t00,t01,t02,t03,t10,t11,t12,t13,t20,t21,t22,t23,t30,t31,t32,t33) { let e00 = this.array[0]; let e10 = this.array[1]; let e20 = this.array[2]; let e30 = this.array[3]; let e01 = this.array[4]; let e11 = this.array[5]; let e21 = this.array[6]; let e31 = this.array[7]; let e02 = this.array[8]; let e12 = this.array[9]; let e22 = this.array[10]; let e32 = this.array[11]; let e03 = this.array[12]; let e13 = this.array[13]; let e23 = this.array[14]; let e33 = this.array[15]; this.array[0] = e00 * t00 + e01 * t10 + e02 * t20 + e03 * t30; this.array[1] = e10 * t00 + e11 * t10 + e12 * t20 + e13 * t30; this.array[2] = e20 * t00 + e21 * t10 + e22 * t20 + e23 * t30; this.array[3] = e30 * t00 + e31 * t10 + e32 * t20 + e33 * t30; this.array[4] = e00 * t01 + e01 * t11 + e02 * t21 + e03 * t31; this.array[5] = e10 * t01 + e11 * t11 + e12 * t21 + e13 * t31; this.array[6] = e20 * t01 + e21 * t11 + e22 * t21 + e23 * t31; this.array[7] = e30 * t01 + e31 * t11 + e32 * t21 + e33 * t31; this.array[8] = e00 * t02 + e01 * t12 + e02 * t22 + e03 * t32; this.array[9] = e10 * t02 + e11 * t12 + e12 * t22 + e13 * t32; this.array[10] = e20 * t02 + e21 * t12 + e22 * t22 + e23 * t32; this.array[11] = e30 * t02 + e31 * t12 + e32 * t22 + e33 * t32; this.array[12] = e00 * t03 + e01 * t13 + e02 * t23 + e03 * t33; this.array[13] = e10 * t03 + e11 * t13 + e12 * t23 + e13 * t33; this.array[14] = e20 * t03 + e21 * t13 + e22 * t23 + e23 * t33; this.array[15] = e30 * t03 + e31 * t13 + e32 * t23 + e33 * t33; } mul(a,b) { let a00 = a.array[0]; let a10 = a.array[1]; let a20 = a.array[2]; let a30 = a.array[3]; let a01 = a.array[4]; let a11 = a.array[5]; let a21 = a.array[6]; let a31 = a.array[7]; let a02 = a.array[8]; let a12 = a.array[9]; let a22 = a.array[10]; let a32 = a.array[11]; let a03 = a.array[12]; let a13 = a.array[13]; let a23 = a.array[14]; let a33 = a.array[15]; let b00 = b.array[0]; let b10 = b.array[1]; let b20 = b.array[2]; let b30 = b.array[3]; let b01 = b.array[4]; let b11 = b.array[5]; let b21 = b.array[6]; let b31 = b.array[7]; let b02 = b.array[8]; let b12 = b.array[9]; let b22 = b.array[10]; let b32 = b.array[11]; let b03 = b.array[12]; let b13 = b.array[13]; let b23 = b.array[14]; let b33 = b.array[15]; this.array[0] = a00 * b00 + a01 * b10 + a02 * b20 + a03 * b30; this.array[1] = a10 * b00 + a11 * b10 + a12 * b20 + a13 * b30; this.array[2] = a20 * b00 + a21 * b10 + a22 * b20 + a23 * b30; this.array[3] = a30 * b00 + a31 * b10 + a32 * b20 + a33 * b30; this.array[4] = a00 * b01 + a01 * b11 + a02 * b21 + a03 * b31; this.array[5] = a10 * b01 + a11 * b11 + a12 * b21 + a13 * b31; this.array[6] = a20 * b01 + a21 * b11 + a22 * b21 + a23 * b31; this.array[7] = a30 * b01 + a31 * b11 + a32 * b21 + a33 * b31; this.array[8] = a00 * b02 + a01 * b12 + a02 * b22 + a03 * b32; this.array[9] = a10 * b02 + a11 * b12 + a12 * b22 + a13 * b32; this.array[10] = a20 * b02 + a21 * b12 + a22 * b22 + a23 * b32; this.array[11] = a30 * b02 + a31 * b12 + a32 * b22 + a33 * b32; this.array[12] = a00 * b03 + a01 * b13 + a02 * b23 + a03 * b33; this.array[13] = a10 * b03 + a11 * b13 + a12 * b23 + a13 * b33; this.array[14] = a20 * b03 + a21 * b13 + a22 * b23 + a23 * b33; this.array[15] = a30 * b03 + a31 * b13 + a32 * b23 + a33 * b33; } transpose(a) { let e01 = a.array[1]; let e02 = a.array[2]; let e03 = a.array[3]; let e10 = a.array[4]; let e11 = a.array[5]; let e12 = a.array[6]; let e13 = a.array[7]; let e20 = a.array[8]; let e21 = a.array[9]; let e22 = a.array[10]; let e23 = a.array[11]; let e30 = a.array[12]; let e31 = a.array[13]; let e32 = a.array[14]; let e33 = a.array[15]; this.array[0] = a.array[0]; this.array[1] = e10; this.array[2] = e20; this.array[3] = e30; this.array[4] = e01; this.array[5] = e11; this.array[6] = e21; this.array[7] = e31; this.array[8] = e02; this.array[9] = e12; this.array[10] = e22; this.array[11] = e32; this.array[12] = e03; this.array[13] = e13; this.array[14] = e23; this.array[15] = e33; } inverse(a) { let e00 = a.array[0]; let e10 = a.array[1]; let e20 = a.array[2]; let e30 = a.array[3]; let e01 = a.array[4]; let e11 = a.array[5]; let e21 = a.array[6]; let e31 = a.array[7]; let e02 = a.array[8]; let e12 = a.array[9]; let e22 = a.array[10]; let e32 = a.array[11]; let e03 = a.array[12]; let e13 = a.array[13]; let e23 = a.array[14]; let e33 = a.array[15]; let d01_01 = e00 * e11 - e01 * e10; let d01_02 = e00 * e12 - e02 * e10; let d01_03 = e00 * e13 - e03 * e10; let d01_12 = e01 * e12 - e02 * e11; let d01_13 = e01 * e13 - e03 * e11; let d01_23 = e02 * e13 - e03 * e12; let d23_01 = e20 * e31 - e21 * e30; let d23_02 = e20 * e32 - e22 * e30; let d23_03 = e20 * e33 - e23 * e30; let d23_12 = e21 * e32 - e22 * e31; let d23_13 = e21 * e33 - e23 * e31; let d23_23 = e22 * e33 - e23 * e32; let d00 = e11 * d23_23 - e12 * d23_13 + e13 * d23_12; let d01 = e10 * d23_23 - e12 * d23_03 + e13 * d23_02; let d02 = e10 * d23_13 - e11 * d23_03 + e13 * d23_01; let d03 = e10 * d23_12 - e11 * d23_02 + e12 * d23_01; let invDet = e00 * d00 - e01 * d01 + e02 * d02 - e03 * d03; if(invDet != 0) { invDet = 1 / invDet; } this.array[0] = d00 * invDet; this.array[1] = -d01 * invDet; this.array[2] = d02 * invDet; this.array[3] = -d03 * invDet; this.array[4] = -(e01 * d23_23 - e02 * d23_13 + e03 * d23_12) * invDet; this.array[5] = (e00 * d23_23 - e02 * d23_03 + e03 * d23_02) * invDet; this.array[6] = -(e00 * d23_13 - e01 * d23_03 + e03 * d23_01) * invDet; this.array[7] = (e00 * d23_12 - e01 * d23_02 + e02 * d23_01) * invDet; this.array[8] = (e31 * d01_23 - e32 * d01_13 + e33 * d01_12) * invDet; this.array[9] = -(e30 * d01_23 - e32 * d01_03 + e33 * d01_02) * invDet; this.array[10] = (e30 * d01_13 - e31 * d01_03 + e33 * d01_01) * invDet; this.array[11] = -(e30 * d01_12 - e31 * d01_02 + e32 * d01_01) * invDet; this.array[12] = -(e21 * d01_23 - e22 * d01_13 + e23 * d01_12) * invDet; this.array[13] = (e20 * d01_23 - e22 * d01_03 + e23 * d01_02) * invDet; this.array[14] = -(e20 * d01_13 - e21 * d01_03 + e23 * d01_01) * invDet; this.array[15] = (e20 * d01_12 - e21 * d01_02 + e22 * d01_01) * invDet; } appendTranslation(tx,ty,tz) { this.array[12] += this.array[0] * tx + this.array[4] * ty + this.array[8] * tz; this.array[13] += this.array[1] * tx + this.array[5] * ty + this.array[9] * tz; this.array[14] += this.array[2] * tx + this.array[6] * ty + this.array[10] * tz; this.array[15] += this.array[3] * tx + this.array[7] * ty + this.array[11] * tz; } toMat3() { this.array3[0] = this.array[0]; this.array3[1] = this.array[1]; this.array3[2] = this.array[2]; this.array3[3] = this.array[4]; this.array3[4] = this.array[5]; this.array3[5] = this.array[6]; this.array3[6] = this.array[8]; this.array3[7] = this.array[9]; this.array3[8] = this.array[10]; } } pot_graphics__$Graphics_UniformMatrix.__name__ = true; class pot_graphics_IndexBuffer { constructor(gl) { this.gl = gl; this.array = new Int32Array(512); this.length = 0; this.buffer = gl.createBuffer(); } } pot_graphics_IndexBuffer.__name__ = true; class pot_graphics_Shader { constructor(gl) { this.gl = gl; this.pg = gl.createProgram(); this.vs = gl.createShader(35633); this.fs = gl.createShader(35632); this.map = null; this.vSource = null; this.fSource = null; this.compiled = false; this.uniforms = new haxe_ds_StringMap(); } setInt(name,x,y,z,w) { let uniform = this.uniforms.h[name]; if(uniform == null) { uniform = new pot_graphics__$Shader_Uniform(); } uniform.type = 0; uniform.i1 = x; if(y != null) { uniform.type = 1; uniform.i2 = y; } if(z != null) { uniform.type = 2; uniform.i3 = z; } if(w != null) { uniform.type = 3; uniform.i4 = w; } this.uniforms.h[name] = uniform; } setFloat(name,x,y,z,w) { let uniform = this.uniforms.h[name]; if(uniform == null) { uniform = new pot_graphics__$Shader_Uniform(); } uniform.type = 4; uniform.f1 = x; if(y != null) { uniform.type = 5; uniform.f2 = y; } if(z != null) { uniform.type = 6; uniform.f3 = z; } if(w != null) { uniform.type = 7; uniform.f4 = w; } this.uniforms.h[name] = uniform; } setMatrix(name,mat) { let uniform = this.uniforms.h[name]; if(uniform == null) { uniform = new pot_graphics__$Shader_Uniform(); } switch(mat.length) { case 4: uniform.type = 8; if(uniform.m2 == null) { uniform.m2 = new Float32Array(4); } uniform.m2[0] = mat[0]; uniform.m2[1] = mat[1]; uniform.m2[2] = mat[2]; uniform.m2[3] = mat[3]; break; case 9: uniform.type = 9; if(uniform.m3 == null) { uniform.m3 = new Float32Array(9); } uniform.m3[0] = mat[0]; uniform.m3[1] = mat[1]; uniform.m3[2] = mat[2]; uniform.m3[3] = mat[3]; uniform.m3[4] = mat[4]; uniform.m3[5] = mat[5]; uniform.m3[6] = mat[6]; uniform.m3[7] = mat[7]; uniform.m3[8] = mat[8]; break; case 16: uniform.type = 10; if(uniform.m4 == null) { uniform.m4 = new Float32Array(16); } uniform.m4[0] = mat[0]; uniform.m4[1] = mat[1]; uniform.m4[2] = mat[2]; uniform.m4[3] = mat[3]; uniform.m4[4] = mat[4]; uniform.m4[5] = mat[5]; uniform.m4[6] = mat[6]; uniform.m4[7] = mat[7]; uniform.m4[8] = mat[8]; uniform.m4[9] = mat[9]; uniform.m4[10] = mat[10]; uniform.m4[11] = mat[11]; uniform.m4[12] = mat[12]; uniform.m4[13] = mat[13]; uniform.m4[14] = mat[14]; uniform.m4[15] = mat[15]; break; default: throw new Error("invalid matrix array length: " + mat.length); } this.uniforms.h[name] = uniform; } setTexture(name,tex) { let uniform = this.uniforms.h[name]; if(uniform == null) { uniform = new pot_graphics__$Shader_Uniform(); } uniform.type = 11; uniform.tex = tex; this.uniforms.h[name] = uniform; } } pot_graphics_Shader.__name__ = true; class pot_graphics__$Shader_Uniform { constructor() { } } pot_graphics__$Shader_Uniform.__name__ = true; class pot_graphics_Texture { constructor(gl) { this.gl = gl; this.texture = null; this.texWrap = 33071; this.texFilter = 9729; this.texture = gl.createTexture(); this.frameBuffer = gl.createFramebuffer(); this.depthBuffer = gl.createRenderbuffer(); } } pot_graphics_Texture.__name__ = true; class pot_graphics_VertexBuffer { constructor(gl,name,size) { this.gl = gl; this.name = name; this.size = size; this.array = new Float32Array(64); this.length = 0; this.buffer = gl.createBuffer(); } } pot_graphics_VertexBuffer.__name__ = true; class pot_input_CodeValue { static fromString(code) { if(pot_input_CodeValue.ALL.indexOf(code) == -1) { return null; } return code; } } class pot_input_Input { constructor(canvas,pot) { this.mouse = new pot_input_Mouse(); this.touches = new pot_input_TouchesData(); this.keyboard = new pot_input_KeyboardData(); this.scalingMode = 1; this.addEvents(canvas,pot); } addEvents(canvas,pot) { this.mouse.addEvents(canvas,canvas,this,pot); let this1 = this.touches; let canvas1 = canvas; let elem = canvas; let input = this; let pot1 = pot; elem.addEventListener("touchstart",function(e) { if(e.cancelable) { e.preventDefault(); } let touches = e.changedTouches; let _g = 0; let _g1 = touches.length; while(_g < _g1) { let rawTouch = touches[_g++]; let touch = this1.getByRawId(rawTouch.identifier,true); let x = rawTouch.clientX - elem.getBoundingClientRect().left; let x1; switch(input.scalingMode) { case 0: x1 = canvas1.width / pot1.pixelRatio / canvas1.clientWidth; break; case 1: x1 = canvas1.width / canvas1.clientWidth; break; } let x2 = x * x1; let y = rawTouch.clientY - elem.getBoundingClientRect().top; let y1; switch(input.scalingMode) { case 0: y1 = canvas1.height / pot1.pixelRatio / canvas1.clientHeight; break; case 1: y1 = canvas1.height / canvas1.clientHeight; break; } touch.nx = x2; touch.ny = y * y1; touch.ntouching = true; touch.ntouching2 = true; } }); elem.addEventListener("touchmove",function(e) { if(e.cancelable) { e.preventDefault(); } let touches = e.changedTouches; let _g = 0; let _g1 = touches.length; while(_g < _g1) { let rawTouch = touches[_g++]; let touch = this1.getByRawId(rawTouch.identifier); if(touch != null) { let x = rawTouch.clientX - elem.getBoundingClientRect().left; let x1; switch(input.scalingMode) { case 0: x1 = canvas1.width / pot1.pixelRatio / canvas1.clientWidth; break; case 1: x1 = canvas1.width / canvas1.clientWidth; break; } let x2 = x * x1; let y = rawTouch.clientY - elem.getBoundingClientRect().top; let y1; switch(input.scalingMode) { case 0: y1 = canvas1.height / pot1.pixelRatio / canvas1.clientHeight; break; case 1: y1 = canvas1.height / canvas1.clientHeight; break; } touch.nx = x2; touch.ny = y * y1; } } }); let end = function(e) { if(e.cancelable) { e.preventDefault(); } let touches = e.changedTouches; let _g = 0; let _g1 = touches.length; while(_g < _g1) { let rawTouch = touches[_g++]; let touch = this1.getByRawId(rawTouch.identifier); if(touch != null) { let x = rawTouch.clientX - elem.getBoundingClientRect().left; let x1; switch(input.scalingMode) { case 0: x1 = canvas1.width / pot1.pixelRatio / canvas1.clientWidth; break; case 1: x1 = canvas1.width / canvas1.clientWidth; break; } let x2 = x * x1; let y = rawTouch.clientY - elem.getBoundingClientRect().top; let y1; switch(input.scalingMode) { case 0: y1 = canvas1.height / pot1.pixelRatio / canvas1.clientHeight; break; case 1: y1 = canvas1.height / canvas1.clientHeight; break; } touch.nx = x2; touch.ny = y * y1; touch.ntouching = false; } } }; elem.addEventListener("touchend",end); elem.addEventListener("touchcancel",end); let this2 = this.keyboard; let elem1 = window.document.body; elem1.addEventListener("keydown",function(e) { let code = pot_input_CodeValue.fromString(e.code); if(code == null) { return; } if(!pot_input_CodeValue.FUNCTIONS.includes(code) && e.cancelable) { e.preventDefault(); } if(!Object.prototype.hasOwnProperty.call(this2.keys.h,code)) { this2.keys.h[code] = new pot_input_Key(); } this2.keys.h[code].press(); this2.ndowns.add(e.key); }); elem1.addEventListener("keyup",function(e) { let code = pot_input_CodeValue.fromString(e.code); if(code == null) { return; } if(!pot_input_CodeValue.FUNCTIONS.includes(code) && e.cancelable) { e.preventDefault(); } if(!Object.prototype.hasOwnProperty.call(this2.keys.h,code)) { this2.keys.h[code] = new pot_input_Key(); } this2.keys.h[code].release(); this2.nups.add(e.key); }); window.addEventListener("blur",function(e) { let h = this2.keys.h; let key_keys = Object.keys(h); let key_length = key_keys.length; let key_current = 0; while(key_current < key_length) h[key_keys[key_current++]].release(); }); } update() { this.mouse.update(); let this1 = this.touches; let i = 0; while(i < this1.touches.length) { let touch = this1.touches[i]; if(!touch.ptouching && !touch.touching && !touch.ntouching) { HxOverrides.remove(this1.touches,touch); } else { touch.update(); ++i; } } let this2 = this.keyboard; let h = this2.keys.h; let key_keys = Object.keys(h); let key_length = key_keys.length; let key_current = 0; while(key_current < key_length) h[key_keys[key_current++]].update(); this2.downs.clear(); this2.ups.clear(); let jsIterator = this2.ndowns.values(); let _g_lastStep = jsIterator.next(); while(!_g_lastStep.done) { let v = _g_lastStep.value; _g_lastStep = jsIterator.next(); this2.downs.add(v); } let jsIterator1 = this2.ups.values(); let _g1_lastStep = jsIterator1.next(); while(!_g1_lastStep.done) { let v = _g1_lastStep.value; _g1_lastStep = jsIterator1.next(); this2.ups.add(v); } this2.ndowns.clear(); this2.nups.clear(); } } pot_input_Input.__name__ = true; class pot_input_Key { constructor() { this.down = false; this.pdown = false; this.ndown = false; this.ndown2 = false; this.ddown = 0; } press() { this.ndown = true; this.ndown2 = true; } release() { this.ndown = false; } update() { this.pdown = this.down; this.down = this.ndown || this.ndown2; this.ndown2 = false; this.ddown = (this.down ? 1 : 0) - (this.pdown ? 1 : 0); } } pot_input_Key.__name__ = true; class pot_input_KeyboardData { constructor() { this.keys = new haxe_ds_StringMap(); this.downs = new Set(); this.ups = new Set(); this.ndowns = new Set(); this.nups = new Set(); } } pot_input_KeyboardData.__name__ = true; class pot_input_Mouse { constructor() { this.px = 0; this.py = 0; this.x = 0; this.y = 0; this.nx = 0; this.ny = 0; this.dx = 0; this.dy = 0; this.wheel = 0; this.nwheel = 0; this.pleft = false; this.pmiddle = false; this.pright = false; this.left = false; this.middle = false; this.right = false; this.nleft = false; this.nmiddle = false; this.nright = false; this.dleft = 0; this.dmiddle = 0; this.dright = 0; this.enabled = false; } addEvents(canvas,elem,input,pot) { let _gthis = this; elem.addEventListener("mousedown",function(e) { _gthis.enabled = true; if(e.cancelable) { e.preventDefault(); } switch(e.button) { case 0: _gthis.nleft = true; _gthis.nleft2 = true; break; case 1: _gthis.nmiddle = true; _gthis.nmiddle2 = true; break; case 2: _gthis.nright = true; _gthis.nright2 = true; break; } let tmp = e.clientX - elem.getBoundingClientRect().left; let tmp1; switch(input.scalingMode) { case 0: tmp1 = canvas.width / pot.pixelRatio / canvas.clientWidth; break; case 1: tmp1 = canvas.width / canvas.clientWidth; break; } _gthis.nx = tmp * tmp1; let tmp2 = e.clientY - elem.getBoundingClientRect().top; let tmp3; switch(input.scalingMode) { case 0: tmp3 = canvas.height / pot.pixelRatio / canvas.clientHeight; break; case 1: tmp3 = canvas.height / canvas.clientHeight; break; } return _gthis.ny = tmp2 * tmp3; }); elem.addEventListener("mouseup",function(e) { _gthis.enabled = true; if(e.cancelable) { e.preventDefault(); } switch(e.button) { case 0: _gthis.nleft = false; break; case 1: _gthis.nmiddle = false; break; case 2: _gthis.nright = false; break; } let tmp = e.clientX - elem.getBoundingClientRect().left; let tmp1; switch(input.scalingMode) { case 0: tmp1 = canvas.width / pot.pixelRatio / canvas.clientWidth; break; case 1: tmp1 = canvas.width / canvas.clientWidth; break; } _gthis.nx = tmp * tmp1; let tmp2 = e.clientY - elem.getBoundingClientRect().top; let tmp3; switch(input.scalingMode) { case 0: tmp3 = canvas.height / pot.pixelRatio / canvas.clientHeight; break; case 1: tmp3 = canvas.height / canvas.clientHeight; break; } return _gthis.ny = tmp2 * tmp3; }); elem.addEventListener("mousemove",function(e) { _gthis.enabled = true; let tmp = e.clientX - elem.getBoundingClientRect().left; let tmp1; switch(input.scalingMode) { case 0: tmp1 = canvas.width / pot.pixelRatio / canvas.clientWidth; break; case 1: tmp1 = canvas.width / canvas.clientWidth; break; } _gthis.nx = tmp * tmp1; let tmp2 = e.clientY - elem.getBoundingClientRect().top; let tmp3; switch(input.scalingMode) { case 0: tmp3 = canvas.height / pot.pixelRatio / canvas.clientHeight; break; case 1: tmp3 = canvas.height / canvas.clientHeight; break; } return _gthis.ny = tmp2 * tmp3; }); elem.addEventListener("wheel",function(e) { let scale; switch(e.deltaMode) { case 0: scale = 1; break; case 1: scale = 24; break; case 2: scale = 720; break; default: throw haxe_Exception.thrown("invalid wheel delta mode"); } _gthis.nwheel += e.deltaY * scale; e.preventDefault(); }); elem.addEventListener("contextmenu",function(e) { _gthis.enabled = true; e.preventDefault(); }); elem.addEventListener("pointerdown",function(e) { elem.setPointerCapture(e.pointerId); }); elem.addEventListener("pointerup",function(e) { elem.releasePointerCapture(e.pointerId); }); } update() { this.px = this.x; this.py = this.y; this.x = this.nx; this.y = this.ny; this.dx = this.x - this.px; this.dy = this.y - this.py; this.pleft = this.left; this.pmiddle = this.middle; this.pright = this.right; this.left = this.nleft || this.nleft2; this.middle = this.nmiddle || this.nmiddle2; this.right = this.nright || this.nright2; this.nleft2 = false; this.nmiddle2 = false; this.nright2 = false; this.dleft = (this.left ? 1 : 0) - (this.pleft ? 1 : 0); this.dmiddle = (this.middle ? 1 : 0) - (this.pmiddle ? 1 : 0); this.dright = (this.right ? 1 : 0) - (this.pright ? 1 : 0); this.wheel = this.nwheel; this.nwheel = 0; } } pot_input_Mouse.__name__ = true; class pot_input_Touch { constructor() { this.px = 0; this.py = 0; this.x = 0; this.y = 0; this.nx = 0; this.ny = 0; this.dx = 0; this.dy = 0; this.ptouching = false; this.touching = false; this.ntouching = false; this.ntouching2 = false; this.dtouching = 0; this.rawId = 0; } update() { this.px = this.x; this.py = this.y; this.x = this.nx; this.y = this.ny; this.dx = this.x - this.px; this.dy = this.y - this.py; this.ptouching = this.touching; this.touching = this.ntouching || this.ntouching2; this.ntouching2 = false; this.dtouching = (this.touching ? 1 : 0) - (this.ptouching ? 1 : 0); } } pot_input_Touch.__name__ = true; class pot_input_TouchesData { constructor() { this.touches = []; } getByRawId(rawId,create) { if(create == null) { create = false; } let _g = 0; let _g1 = this.touches; while(_g < _g1.length) { let t = _g1[_g]; ++_g; if(t.rawId == rawId) { return t; } } if(create) { return this.newTouch(rawId); } else { return null; } } newTouch(rawId) { let minId = 0; while(true) { let tmp = minId; let _g = 0; let _g1 = this.touches; while(_g < _g1.length) if(_g1[_g++].id == minId) { ++minId; } if(tmp == minId) { break; } } let touch = new pot_input_Touch(); touch.rawId = rawId; touch.id = minId; this.touches.push(touch); return touch; } } pot_input_TouchesData.__name__ = true; class pot_util_Timer { constructor(frame) { this.frame = frame; this.targetSleep = 16.666666666666668; this.useAnimationFrame = false; } start() { if(this.running) { return; } this.nextTime = Date.now(); this.running = true; window.setTimeout($bind(this,this.loop),0); } setFrameRate(frameRate) { this.targetSleep = 1000 / frameRate; } setUseAnimationFrame(useAnimationFrame) { this.useAnimationFrame = useAnimationFrame; } loop(arg) { if(!this.running) { return; } if(pot_util_Timer.catchErrors) { try { this.frame(); } catch( _g ) { let _g1 = haxe_Exception.caught(_g).unwrap(); let v = _g1 == null ? "null" : Std.string(_g1); window.alert(Std.string("error: " + v)); } } else { this.frame(); } let currentTime = Date.now(); if((this.nextTime += this.targetSleep) < currentTime + 5) { this.nextTime = currentTime + 5; } let sleep = this.nextTime - currentTime + 0.5 | 0; if(this.useAnimationFrame) { window.requestAnimationFrame($bind(this,this.loop)); } else { window.setTimeout($bind(this,this.loop),sleep); } } } pot_util_Timer.__name__ = true; var $_; function $bind(o,m) { if( m == null ) return null; if( m.__id__ == null ) m.__id__ = $global.$haxeUID++; var f; if( o.hx__closures__ == null ) o.hx__closures__ = {}; else f = o.hx__closures__[m.__id__]; if( f == null ) { f = m.bind(o); o.hx__closures__[m.__id__] = f; } return f; } $global.$haxeUID |= 0; if(typeof(performance) != "undefined" ? typeof(performance.now) == "function" : false) { HxOverrides.now = performance.now.bind(performance); } { String.__name__ = true; Array.__name__ = true; } js_Boot.__toStr = ({ }).toString; pot_core_App._hx_skip_constructor = false; pot_input_CodeValue.FUNCTIONS = ["F1","F2","F3","F4","F5","F6","F7","F8","F9","F10","F11","F12"]; pot_input_CodeValue.ALL = ["Escape","Digit0","Digit1","Digit2","Digit3","Digit4","Digit5","Digit6","Digit7","Digit8","Digit9","Minus","Equal","Backspace","Tab","KeyQ","KeyW","KeyE","KeyR","KeyT","KeyY","KeyU","KeyI","KeyO","KeyP","BracketLeft","BracketRight","Enter","ControlLeft","KeyA","KeyS","KeyD","KeyF","KeyG","KeyH","KeyJ","KeyK","KeyL","Semicolon","Quote","Backquote","ShiftLeft","Backslash","KeyZ","KeyX","KeyC","KeyV","KeyB","KeyN","KeyM","Comma","Period","Slash","ShiftRight","NumpadMultiply","AltLeft","Space","CapsLock","F1","F2","F3","F4","F5","F6","F7","F8","F9","F10","Numpad7","Numpad8","Numpad9","NumpadSubtract","Numpad4","Numpad5","Numpad6","NumpadAdd","Numpad1","Numpad2","Numpad3","Numpad0","NumpadDecimal","IntlBackslash","F11","F12","IntlYen","NumpadEnter","ControlRight","NumpadDivide","PrintScreen","AltRight","NumLock","Home","ArrowUp","PageUp","ArrowLeft","ArrowRight","End","ArrowDown","PageDown","Insert","Delete","ContextMenu"]; pot_util_Timer.catchErrors = false; CableSim.main(); })(typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this);