| /** | |
| * Display Points on the scene, each with its own size and color. | |
| * @example <caption>Simple How to use</caption> | |
| * let dPnt = new DynamicPoints( 200 ); | |
| * Scene.add( dPnt.mesh ); | |
| */ | |
| class DynamicPoints{ | |
| constructor( maxLen = 100 ){ | |
| /** | |
| * How many vertices to draw. |
| class Callbacks{ | |
| constructor(){ | |
| this.cb = {}; | |
| } | |
| on( eName, func ){ | |
| if( !this.cb[ eName ] ) this.cb[ eName ] = new Array(); | |
| this.cb[ eName ].push( func ); | |
| return this; | |
| } |
| class FlatVectorArray{ | |
| constructor( elmCnt=1, compLen=3, type=null ){ | |
| this.elmCnt = elmCnt; | |
| this.compLen = compLen; | |
| this.aryLen = elmCnt * compLen; | |
| this.count = 0; | |
| if( !type ){ | |
| this.aryType = Float32Array; | |
| this.data = new Float32Array( this.aryLen ); |
Collection of algorithms related to using curves written in javascript.
| /* | |
| This is a basic framework for Timeline Animations. This example only animates a single float value, but you may build the frame | |
| class to hold any value type, maybe have different Frame objects based on Type, for example quaternions would need an extra step | |
| for interpolation by normalizing the final value where a vector would not need that. | |
| If buidling this in rust or other languages, Maybe generics would be a good use for creating keyframes of different types. | |
| Or you can build a general purpose keyframe that interpolates multiple values at once. Sky's the limit. | |
| */ | |
| // TRACK - COLLECTION OF ORDERED KEYFRAMES |
| // Bounce back forth between 0 and Max | |
| function triangleWaveInt( i, max ){ | |
| let max2 = max * 2; | |
| i = i - Math.floor( i / max2 ) * max2; // sawtooth wave, but using a max value double | |
| i = Math.max( 0, Math.min( max2, i )); // clamp | |
| return max - Math.abs( i - max ); // triangle Wave | |
| } |
| Radius = ArcLength / Angle | |
| ArcLength = Radius * Angle | |
| Arc / Segment Height = Radius * ( 1 - cos(angle / 2) ) | |
| circleCenterPoint_fromCurve = Radius - Segment Height | |
| chord length = 2 * Radius * sin( angle / 2 ) | |
| circumference = PI * diameter | |
| circumference = PI * radius * 2; |
| let GamepadList = new Array(); | |
| class GamepadTracker{ | |
| constructor( profile ){ | |
| this.gpIndex = -1; | |
| this.profile = profile; | |
| this.timestamp = 0; | |
| this.hasChanged = false; | |
| this.onConnectBind = this.onConnect.bind( this ); |
| /* NOTES | |
| When i create 5 Float32Arrays at 10 million iterations, It takes about 3 seconds to complete. | |
| But if create a Pool of 5 Float arrays and use Get/Rtn at the same interactions is only 0.17s. | |
| So by using ObjectPool, using Float32Arrays for Vector3 data is just as fast as an Object Vector | |
| but uses up less memory and affects garbage collection much less. | |
| let pool = new ObjectPool( THREE.Vector3, 10, 5 ); | |
| let a = pool.get(), | |
| b = pool.get(); | |
| pool.rtn( a ).rtn( b ); |
| // https://www.mathsisfun.com/algebra/trig-solving-sss-triangles.html | |
| static lawcos_sss( aLen, bLen, cLen ){ | |
| // Law of Cosines - SSS : cos(C) = (a^2 + b^2 - c^2) / 2ab | |
| // The Angle between A and B with C being the opposite length of the angle. | |
| return Math.acos( (aLen*aLen + bLen*bLen - cLen*cLen) / (2 * aLen * bLen) ); | |
| } | |
| function limb( chain, target, pose, wt ){ | |
| //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| // Using law of cos SSS, so need the length of all sides of the triangle |