JAVASCRIPT   130

math.js

Guest on 19th July 2021 07:11:18 PM

  1. var     UTL_PID180                                              = Math.PI / 180;
  2. var     UTL_180DPI                                              = 180 / Math.PI;
  3.  
  4. function math_getSpheresCollisionBOOL(vct0, vct1){
  5.         var xdiff                       = vct0.x - vct1.x;
  6.         var ydiff                       = vct0.y - vct1.y;
  7.         var d                           = Math.sqrt(xdiff * xdiff + ydiff * ydiff);
  8.         return d <= (vct0.r + vct1.r);
  9. }
  10.  
  11. function math_deg2Rad(deg){
  12.         return deg * UTL_PID180;
  13. }
  14.  
  15. function math_rad2Deg(rad){
  16.         return rad * UTL_180DPI;
  17. }
  18.  
  19. function math_dotproduct2D(v1, v2){
  20.         return ((v1.x * v2.x) + (v1.y * v2.y));
  21. }              
  22.  
  23. function math_normalize2D(vct){
  24.         var mag                                                 = Math.sqrt((vct.x * vct.x) + (vct.y * vct.y));
  25.         if (mag == 0){
  26.                 mag = 1;
  27.         }
  28.        
  29.         vct.x                                                   /= mag;
  30.         vct.y                                                   /= mag;
  31.         return vct;
  32. }              
  33.  
  34. function math_closestPointOnLine(p1, p2, pt){
  35.         var vct1;
  36.         var vct2;
  37.         var vct3;
  38.        
  39.         vct1.x                                                  = pt.x - p1.x;
  40.         vct1.y                                                  = pt.y - p1.y;
  41.        
  42.         vct2.x                                                  = p2.x - p1.x;
  43.         vct2.y                                                  = p2.y - p1.y;
  44.        
  45.         vct2                                                    = math_normalize2D(vct2);
  46.        
  47.         var d                                                   = Math.sqrt((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
  48.        
  49.         var bounds                                              = math_dotproduct2D(vct2, vct1);
  50.        
  51.         if (bounds <= 0){
  52.                 return p1;
  53.         }
  54.        
  55.         if (bounds >= d){
  56.                 return p2;
  57.         }
  58.        
  59.         vct3.x                                                  = p1.x + vct2.x * bounds;
  60.         vct3.y                                                  = p1.y + vct2.y * bounds;
  61.        
  62.         return vct3;
  63. }              
  64.  
  65. function math_buildRGB(r, g, b){
  66.         return (b | (g << 8) | (r << 16));
  67. }
  68.  
  69. function math_splitRGB(rgb){
  70.         var srgb;
  71.        
  72.         srgb.b                                          = (rgb % 256);
  73.         srgb.g                                          = (rgb & -16711936) / 256;
  74.         srgb.r                                          = (rgb & 16711680 ) / 65536;
  75.        
  76.         return srgb;
  77. }              
  78.  
  79. function math_randRange(min, max){
  80.         return Math.floor(Math.random() * (max - min + 1)) + min;
  81. }
  82.  
  83. function math_getDirMC2D(from, to){
  84.         var dir
  85.         dir.x                                           = to.x - from.x;
  86.         dir.y                                           = to.y - from.y;
  87.        
  88.         var mag                                         = Math.sqrt((dir.x * dir.x) + (dir.y * dir.y));
  89.         if (mag == 0)
  90.         {
  91.                 mag = 1;
  92.         }
  93.        
  94.         dir.x                                           /= mag;
  95.         dir.y                                           /= mag;
  96.        
  97.         return dir;
  98. }
  99.  
  100. function math_angleBTWlines2D(commonPoint, lineEnd1, lineEnd2){
  101.         var v1;
  102.         var v2;
  103.        
  104.         v1.x                                            = lineEnd1.x - commonPoint.x;
  105.         v1.y                                            = lineEnd1.y - commonPoint.y;
  106.        
  107.         v2.x                                            = lineEnd2.x - commonPoint.x;
  108.         v2.y                                            = lineEnd2.y - commonPoint.y;
  109.        
  110.         return math_angleBTWvectors2D(v1, v2);
  111. }
  112.  
  113. function math_angleBTWvectors2D(v1, v2){
  114.         var dot                                         = ((v1.x * v2.x) + (v1.y * v2.y));
  115.         var mag1                                        = Math.sqrt((v1.x * v1.x) + (v1.y * v1.y));
  116.         var mag2                                        = Math.sqrt((v2.x * v2.x) + (v2.y * v2.y));
  117.         var magMul                                      = mag1 * mag2;
  118.         var ang                                         = Math.acos(dot / magMul);
  119.         if ( isNaN(ang))
  120.         {
  121.                 return 0;
  122.         }
  123.        
  124.         return ang;
  125. }
  126.  
  127.  
  128. function math_crossProduct2D(vct1, vct2){
  129.         var pRet;
  130.        
  131.         pRet.x                                          = (vct1.y * 1) - (1 * vct2.y);
  132.         pRet.y                                          = (1 * vct2.x) - (vct1.x * 1);
  133.        
  134.         return pRet;
  135. }
  136.  
  137. function math_randRange(min, max){
  138.         return Math.floor(Math.random() * (max - min + 1)) + min;
  139. }
  140.  
  141. function math_clamp(THETA_MIN, THETA_MAX, LOW_LIMIT, HIGH_LIMIT, THETA){       
  142.         var theta                                       = 1/(THETA_MAX-THETA_MIN) * (THETA - THETA_MIN);
  143.         if(theta > 1){ return HIGH_LIMIT; }
  144.         if(theta < 0){ return LOW_LIMIT; }
  145.         return LOW_LIMIT + (HIGH_LIMIT - LOW_LIMIT) * theta;
  146. }
  147.  
  148. function math_quantomize(array){
  149.         var len                                         = array.length;
  150.        
  151.         var a                                           = 0;
  152.         var b                                           = 0;
  153.         var temp;
  154.        
  155.         for (var i = 0; i<array.length; i++)
  156.         {
  157.                
  158.                 a                                       = Math.floor(Math.random()*len);
  159.                 b                                       = Math.floor(Math.random()*len);
  160.                
  161.                 temp                                    = array[a];
  162.                 array[a]                                = array[b];
  163.                 array[b]                                = temp;
  164.         }
  165. }
  166.  
  167. function math_rotatePoint(vct, ang){
  168.         var o
  169.         o.x                                             = vct.x * Math.cos(ang) - vct.y * Math.sin(ang);
  170.         o.y                                             = vct.y * Math.cos(ang) + vct.x * Math.sin(ang);
  171.         return o
  172. }
  173.  
  174. var aGAUSS                                              = new Array();
  175. aGAUSS[0]                                               = {x:  0.285561, y:  0.188437};
  176. aGAUSS[1]                                               = {x:  0.360176, y: -0.065688};
  177. aGAUSS[2]                                               = {x: -0.111751, y:  0.275019};
  178. aGAUSS[3]                                               = {x: -0.055918, y: -0.215197};
  179. aGAUSS[4]                                               = {x: -0.080231, y: -0.470965};
  180. aGAUSS[5]                                               = {x:  0.138721, y:  0.409168};
  181. aGAUSS[6]                                               = {x:  0.384120, y:  0.458500};
  182. aGAUSS[7]                                               = {x: -0.454968, y:  0.134088};
  183. aGAUSS[8]                                               = {x:  0.179271, y: -0.331196};
  184. aGAUSS[9]                                               = {x: -0.307049, y: -0.364927};
  185. aGAUSS[10]                                              = {x:  0.105354, y: -0.010099};
  186. aGAUSS[11]                                              = {x: -0.154180, y:  0.021794};
  187. aGAUSS[12]                                              = {x: -0.370135, y: -0.116425};
  188. aGAUSS[13]                                              = {x:  0.451636, y: -0.300013};
  189. aGAUSS[14]                                              = {x: -0.370610, y:  0.387504};
  190.  
  191. function math_getGauss(){
  192.         return aGAUSS[math_randRange(0, 14)];
  193. }

Raw Paste


Login or Register to edit or fork this paste. It's free.