Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. #include "rsmx.h"
  2.  
  3. #ifdef RS_USE_C_LIBS
  4.     #include <string.h>
  5.     #include <math.h>
  6. #else
  7.     #include "rsplatform.h"
  8. #endif
  9.  
  10. #include "rsdebug.h"
  11.  
  12. // Some matrix and vector stuff
  13. // by Roman Shuvalov
  14.  
  15.  
  16. rs_vec3_t rs_vec3_sub(rs_vec3_t v1, rs_vec3_t v2) {
  17.     return rs_vec3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
  18. };
  19.  
  20. rs_vec3_t rs_vec3_add(rs_vec3_t v1, rs_vec3_t v2) {
  21.     return rs_vec3( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z );
  22. };
  23.  
  24. rs_vec3_t rs_vec3_mult(rs_vec3_t v, float s) {
  25.     return rs_vec3( v.x * s, v.y * s, v.z * s );
  26. };
  27.  
  28.  
  29. rs_vec4_t rs_vec4_sub(rs_vec4_t v1, rs_vec4_t v2) {
  30.     rs_vec4_t dest;
  31.     dest.x = v1.x - v2.x;
  32.     dest.y = v1.y - v2.y;
  33.     dest.z = v1.z - v2.z;
  34.     dest.w = v1.z - v2.w;
  35.     return dest;
  36. };
  37.  
  38.  
  39. rs_vec4_t rs_vec4(float x, float y, float z, float w) {
  40.     rs_vec4_t r;
  41.     r.x = x;
  42.     r.y = y;
  43.     r.z = z;
  44.     r.w = w;
  45.     return r;
  46. };
  47.  
  48. rs_vec3_t rs_vec3(float x, float y, float z) {
  49.     rs_vec3_t r;
  50.     r.x = x;
  51.     r.y = y;
  52.     r.z = z;
  53.     return r;
  54. };
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61. float rs_vec4_length_sqr(rs_vec4_t src) {
  62.     return src.x*src.x + src.y*src.y + src.z*src.z + src.w*src.w;
  63. };
  64.  
  65. float rs_vec3_length_sqr(rs_vec3_t src) {
  66.     return src.x*src.x + src.y*src.y + src.z*src.z;
  67. };
  68.  
  69.  
  70.  
  71.  
  72. float rs_vec4_length(rs_vec4_t v) {
  73.     return sqrtf( rs_vec4_length_sqr(v) );
  74. };
  75.  
  76. float rs_vec3_length(rs_vec3_t v) {
  77.     return sqrtf( rs_vec3_length_sqr(v) );
  78. };
  79.  
  80.  
  81.  
  82.  
  83. rs_vec3_t rs_vec3_normalize(rs_vec3_t v) {
  84.     float s = rs_vec3_length(v);
  85.     if (s > 0.00001) {
  86.         return rs_vec3( v.x / s, v.y / s, v.z / s );
  87.     }
  88.     return rs_vec3(0.0, 0.0, 0.0);
  89. };
  90.  
  91.  
  92.  
  93. float rs_vec4_dot(rs_vec4_t v1, rs_vec4_t v2) {
  94.     return ( (v1.x) * (v2.x) ) + (v1.y * v2.y) + (v1.z * v2.z) + (v1.w * v2.w);
  95. };
  96.  
  97. float rs_vec3_dot(rs_vec3_t v1, rs_vec3_t v2) {
  98.     return (v1.x) * (v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
  99. };
  100.  
  101.  
  102.  
  103.  
  104. rs_vec3_t rs_vec3_cross(rs_vec3_t u, rs_vec3_t v) {
  105.     rs_vec3_t d;
  106.  
  107.     d.x = u.y * v.z - u.z * v.y;
  108.     d.y = u.z * v.x - u.x * v.z;
  109.     d.z = u.x * v.y - u.y * v.x;
  110.  
  111.     return d;
  112.  
  113. };
  114.  
  115.  
  116.  
  117. float rs_vec4_angle(rs_vec4_t u, rs_vec4_t v) {
  118.     return rs_vec4_dot(u, v) / (rs_vec4_length(u) * rs_vec4_length(v) );
  119. };
  120.  
  121. float rs_vec3_cos_angle(rs_vec3_t u, rs_vec3_t v) {
  122.     float ret = rs_vec3_dot(u, v) / (rs_vec3_length(u) * rs_vec3_length(v) );
  123.     return ret;
  124. };
  125.  
  126. float rs_vec3_distance_sqr(rs_vec3_t u, rs_vec3_t v) {
  127.     return rs_vec3_length_sqr( rs_vec3(u.x - v.x, u.y - v.y, u.z - v.z) );
  128. };
  129.  
  130.  
  131. float rs_clamp(float x, float min1, float max1) {
  132.     if (x < min1) {
  133.         return min1;
  134.     };
  135.     if (x > max1) {
  136.         return max1;
  137.     };
  138.     return x;
  139. };
  140.  
  141. int rs_clamp_i(int x, int min1, int max1) {
  142.     if (x < min1) {
  143.         return min1;
  144.     };
  145.     if (x > max1) {
  146.         return max1;
  147.     };
  148.     return x;
  149. };
  150.  
  151. float rs_exp_interpolate(float v_from, float v_to, float dt) {
  152.     return v_from + ( v_to - v_from ) * ( 1 - exp(-dt/1.0) );
  153. };
  154.  
  155. float rs_max(float x, float y) {
  156.     return x > y ? x : y;
  157. };
  158.  
  159. float rs_min(float x, float y) {
  160.     return x < y ? x : y;
  161. };
  162.  
  163. float rs_sign(float f) {
  164.     return (f >= 0.0) ? 1.0 : -1.0;
  165. };
  166.  
  167. float rs_pow(float f, float p) {
  168.     return rs_sign(f) * pow( fabs(f), p );
  169. };
  170.  
  171. float rs_clamp_angle(float f) { // !!!! only one iteration
  172.     if (f > 2.0*M_PI) {
  173.         return f - 2.0*M_PI;
  174.     };
  175.    
  176.     if (f < -2.0*M_PI) {
  177.         return f + 2.0*M_PI;
  178.     };
  179.    
  180.     return f;
  181. };
  182.  
  183. float rs_linear_interpolate(float v_from, float v_to, float t) {
  184.     return v_from*(1.0-t) + v_to*t;
  185. };
  186.  
  187. float rs_fract(float f) {
  188.     float r = floor(f);
  189.     return f - r;
  190. };
  191.  
  192.  
  193.