source/blender/blenlib/intern/vectorops.c

   1 /*
   2  *
   3  * Some vector operations.
   4  *
   5  * Always use
   6  * - vector with x components :   float x[3], int x[3], etc
   7  *
   8  * $Id$
   9  *
  10  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version. The Blender
  16  * Foundation also sells licenses for use in proprietary software under
  17  * the Blender License.  See http://www.blender.org/BL/ for information
  18  * about this.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software Foundation,
  27  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  28  *
  29  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  30  * All rights reserved.
  31  *
  32  * The Original Code is: all of this file.
  33  *
  34  * Contributor(s): none yet.
  35  *
  36  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  37  */
  38
  39 /* ------------------------------------------------------------------------- */
  40 /* General format: op(a, b, c): a = b op c                                   */
  41 /* Copying is done cp <from, to>                                             */
  42 /* ------------------------------------------------------------------------- */
  43
  44 #include "MTC_vectorops.h"
  45 #include <math.h>
  46
  47 #ifdef HAVE_CONFIG_H
  48 #include <config.h>
  49 #endif
  50
  51 void MTC_diff3Int(int v1[3], int v2[3], int v3[3])
  52 {
  53         v1[0] = v2[0] - v3[0];
  54         v1[1] = v2[1] - v3[1];
  55         v1[2] = v2[2] - v3[2];
  56 }
  57
  58 /* ------------------------------------------------------------------------- */
  59 void MTC_diff3Float(float v1[3], float v2[3], float v3[3])
  60 {
  61         v1[0] = v2[0] - v3[0];
  62         v1[1] = v2[1] - v3[1];
  63         v1[2] = v2[2] - v3[2];
  64 }
  65
  66 /* ------------------------------------------------------------------------- */
  67
  68 void MTC_cross3Int(int v1[3], int v2[3], int v3[3])
  69 {
  70         v1[0] = v2[1]*v3[2] - v2[2]*v3[1];
  71         v1[1] = v2[2]*v3[0] - v2[0]*v3[2];
  72         v1[2] = v2[0]*v3[1] - v2[1]*v3[0];
  73 }
  74
  75 /* ------------------------------------------------------------------------- */
  76
  77 void MTC_cross3Float(float v1[3], float v2[3], float v3[3])
  78 {
  79         v1[0] = v2[1]*v3[2] - v2[2]*v3[1];
  80         v1[1] = v2[2]*v3[0] - v2[0]*v3[2];
  81         v1[2] = v2[0]*v3[1] - v2[1]*v3[0];
  82 }
  83 /* ------------------------------------------------------------------------- */
  84
  85 void MTC_cross3Double(double v1[3], double v2[3], double v3[3])
  86 {
  87         v1[0] = v2[1]*v3[2] - v2[2]*v3[1];
  88         v1[1] = v2[2]*v3[0] - v2[0]*v3[2];
  89         v1[2] = v2[0]*v3[1] - v2[1]*v3[0];
  90 }
  91
  92 /* ------------------------------------------------------------------------- */
  93
  94 int MTC_dot3Int(int v1[3], int v2[3])
  95 {
  96         return (v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]);
  97 }
  98
  99 /* ------------------------------------------------------------------------- */
 100
 101 float MTC_dot3Float(float v1[3], float v2[3])
 102 {
 103         return (v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]);
 104 }
 105
 106 /* ------------------------------------------------------------------------- */
 107
 108 void MTC_cp3Float(float v1[3], float v2[3])
 109 {
 110         v2[0] = v1[0];
 111         v2[1] = v1[1];
 112         v2[2] = v1[2];
 113 }
 114
 115 /* ------------------------------------------------------------------------- */
 116
 117 void MTC_cp3FloatInv(float v1[3], float v2[3])
 118 {
 119         v2[0] = -v1[0];
 120         v2[1] = -v1[1];
 121         v2[2] = -v1[2];
 122 }
 123
 124 /* ------------------------------------------------------------------------- */
 125
 126 void MTC_swapInt(int *i1, int *i2)
 127 {
 128         int swap;
 129         swap = *i1;
 130         *i1 = *i2;
 131         *i2 = swap;
 132 }
 133
 134 /* ------------------------------------------------------------------------- */
 135
 136 void  MTC_diff3DFF(double v1[3], float v2[3], float v3[3])
 137 {
 138         v1[0] = v2[0] - v3[0];
 139         v1[1] = v2[1] - v3[1];
 140         v1[2] = v2[2] - v3[2];
 141 }
 142
 143 /* ------------------------------------------------------------------------- */
 144 float MTC_normalise3DF(float n[3])
 145 {
 146         float d;
 147
 148         d= n[0]*n[0]+n[1]*n[1]+n[2]*n[2];
 149         /* FLT_EPSILON is too large! A larger value causes normalise errors in   */
 150         /* a scaled down utah teapot                                             */
 151         if(d>0.0000000000001) {
 152
 153                 /* d= sqrt(d);  This _should_ be sqrt, but internally it's a double*/
 154                 /* anyway. This is safe.                                             */
 155                 d = sqrt(d);
 156
 157                 n[0]/=d;
 158                 n[1]/=d;
 159                 n[2]/=d;
 160         } else {
 161                 n[0]=n[1]=n[2]= 0.0;
 162                 d= 0.0;
 163         }
 164         return d;
 165 }
 166
 167 /* ------------------------------------------------------------------------- */
 168
 169 /* eof */