Blender: mathutils_Vector.c Source File

Blender V2.59
00001 /*
00002  * $Id: mathutils_Vector.c 39300 2011-08-11 09:40:14Z moguri $
00003  * ***** BEGIN GPL LICENSE BLOCK *****
00004  *
00005  * This program is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU General Public License
00007  * as published by the Free Software Foundation; either version 2
00008  * of the License, or (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software Foundation,
00017  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00018  *
00019  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
00020  * All rights reserved.
00021  *
00022  *
00023  * Contributor(s): Willian P. Germano, Joseph Gilbert, Ken Hughes, Alex Fraser, Campbell Barton
00024  *
00025  * ***** END GPL LICENSE BLOCK *****
00026  */
00027 
00033 #include <Python.h>
00034 
00035 #include "mathutils.h"
00036 
00037 #include "BLI_math.h"
00038 #include "BLI_utildefines.h"
00039 
00040 extern void PyC_LineSpit(void);
00041 
00042 #define MAX_DIMENSIONS 4
00043 
00044 /* Swizzle axes get packed into a single value that is used as a closure. Each
00045    axis uses SWIZZLE_BITS_PER_AXIS bits. The first bit (SWIZZLE_VALID_AXIS) is
00046    used as a sentinel: if it is unset, the axis is not valid. */
00047 #define SWIZZLE_BITS_PER_AXIS 3
00048 #define SWIZZLE_VALID_AXIS 0x4
00049 #define SWIZZLE_AXIS       0x3
00050 
00051 static PyObject *Vector_copy(VectorObject *self);
00052 static PyObject *Vector_to_tuple_ext(VectorObject *self, int ndigits);
00053 
00054 /* Supports 2D, 3D, and 4D vector objects both int and float values
00055  * accepted. Mixed float and int values accepted. Ints are parsed to float
00056  */
00057 static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED(kwds))
00058 {
00059         float vec[4]= {0.0f, 0.0f, 0.0f, 0.0f};
00060         int size= 3; /* default to a 3D vector */
00061 
00062         switch(PyTuple_GET_SIZE(args)) {
00063         case 0:
00064                 break;
00065         case 1:
00066                 if((size=mathutils_array_parse(vec, 2, 4, PyTuple_GET_ITEM(args, 0), "mathutils.Vector()")) == -1)
00067                         return NULL;
00068                 break;
00069         default:
00070                 PyErr_SetString(PyExc_TypeError,
00071                                 "mathutils.Vector(): "
00072                                 "more then a single arg given");
00073                 return NULL;
00074         }
00075         return newVectorObject(vec, size, Py_NEW, type);
00076 }
00077 
00078 static PyObject *vec__apply_to_copy(PyNoArgsFunction vec_func, VectorObject *self)
00079 {
00080         PyObject *ret= Vector_copy(self);
00081         PyObject *ret_dummy= vec_func(ret);
00082         if(ret_dummy) {
00083                 Py_DECREF(ret_dummy);
00084                 return (PyObject *)ret;
00085         }
00086         else { /* error */
00087                 Py_DECREF(ret);
00088                 return NULL;
00089         }
00090 }
00091 
00092 /*-----------------------------METHODS---------------------------- */
00093 PyDoc_STRVAR(Vector_zero_doc,
00094 ".. method:: zero()\n"
00095 "\n"
00096 "   Set all values to zero.\n"
00097 );
00098 static PyObject *Vector_zero(VectorObject *self)
00099 {
00100         fill_vn(self->vec, self->size, 0.0f);
00101 
00102         if(BaseMath_WriteCallback(self) == -1)
00103                 return NULL;
00104 
00105         Py_RETURN_NONE;
00106 }
00107 
00108 PyDoc_STRVAR(Vector_normalize_doc,
00109 ".. method:: normalize()\n"
00110 "\n"
00111 "   Normalize the vector, making the length of the vector always 1.0.\n"
00112 "\n"
00113 "   .. warning:: Normalizing a vector where all values are zero results\n"
00114 "      in all axis having a nan value (not a number).\n"
00115 "\n"
00116 "   .. note:: Normalize works for vectors of all sizes,\n"
00117 "      however 4D Vectors w axis is left untouched.\n"
00118 );
00119 static PyObject *Vector_normalize(VectorObject *self)
00120 {
00121         int i;
00122         float norm = 0.0f;
00123 
00124         if(BaseMath_ReadCallback(self) == -1)
00125                 return NULL;
00126 
00127         for(i = 0; i < self->size; i++) {
00128                 norm += self->vec[i] * self->vec[i];
00129         }
00130         norm = (float) sqrt(norm);
00131         for(i = 0; i < self->size; i++) {
00132                 self->vec[i] /= norm;
00133         }
00134 
00135         (void)BaseMath_WriteCallback(self);
00136         Py_RETURN_NONE;
00137 }
00138 PyDoc_STRVAR(Vector_normalized_doc,
00139 ".. method:: normalized()\n"
00140 "\n"
00141 "   Return a new, normalized vector.\n"
00142 "\n"
00143 "   :return: a normalized copy of the vector\n"
00144 "   :rtype: :class:`Vector`\n"
00145 );
00146 static PyObject *Vector_normalized(VectorObject *self)
00147 {
00148         return vec__apply_to_copy((PyNoArgsFunction)Vector_normalize, self);
00149 }
00150 
00151 PyDoc_STRVAR(Vector_resize_2d_doc,
00152 ".. method:: resize_2d()\n"
00153 "\n"
00154 "   Resize the vector to 2D  (x, y).\n"
00155 "\n"
00156 "   :return: an instance of itself\n"
00157 "   :rtype: :class:`Vector`\n"
00158 );
00159 static PyObject *Vector_resize_2d(VectorObject *self)
00160 {
00161         if(self->wrapped==Py_WRAP) {
00162                 PyErr_SetString(PyExc_TypeError,
00163                                 "vector.resize_2d(): "
00164                                 "cannot resize wrapped data - only python vectors");
00165                 return NULL;
00166         }
00167         if(self->cb_user) {
00168                 PyErr_SetString(PyExc_TypeError,
00169                                 "vector.resize_2d(): "
00170                                 "cannot resize a vector that has an owner");
00171                 return NULL;
00172         }
00173 
00174         self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 2));
00175         if(self->vec == NULL) {
00176                 PyErr_SetString(PyExc_MemoryError,
00177                                 "vector.resize_2d(): "
00178                                 "problem allocating pointer space");
00179                 return NULL;
00180         }
00181 
00182         self->size = 2;
00183         Py_RETURN_NONE;
00184 }
00185 
00186 PyDoc_STRVAR(Vector_resize_3d_doc,
00187 ".. method:: resize_3d()\n"
00188 "\n"
00189 "   Resize the vector to 3D  (x, y, z).\n"
00190 "\n"
00191 "   :return: an instance of itself\n"
00192 "   :rtype: :class:`Vector`\n"
00193 );
00194 static PyObject *Vector_resize_3d(VectorObject *self)
00195 {
00196         if (self->wrapped==Py_WRAP) {
00197                 PyErr_SetString(PyExc_TypeError,
00198                                 "vector.resize_3d(): "
00199                                 "cannot resize wrapped data - only python vectors");
00200                 return NULL;
00201         }
00202         if(self->cb_user) {
00203                 PyErr_SetString(PyExc_TypeError,
00204                                 "vector.resize_3d(): "
00205                                 "cannot resize a vector that has an owner");
00206                 return NULL;
00207         }
00208 
00209         self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 3));
00210         if(self->vec == NULL) {
00211                 PyErr_SetString(PyExc_MemoryError,
00212                                 "vector.resize_3d(): "
00213                                 "problem allocating pointer space");
00214                 return NULL;
00215         }
00216 
00217         if(self->size == 2)
00218                 self->vec[2] = 0.0f;
00219 
00220         self->size = 3;
00221         Py_RETURN_NONE;
00222 }
00223 
00224 PyDoc_STRVAR(Vector_resize_4d_doc,
00225 ".. method:: resize_4d()\n"
00226 "\n"
00227 "   Resize the vector to 4D (x, y, z, w).\n"
00228 "\n"
00229 "   :return: an instance of itself\n"
00230 "   :rtype: :class:`Vector`\n"
00231 );
00232 static PyObject *Vector_resize_4d(VectorObject *self)
00233 {
00234         if(self->wrapped==Py_WRAP) {
00235                 PyErr_SetString(PyExc_TypeError,
00236                                 "vector.resize_4d(): "
00237                                 "cannot resize wrapped data - only python vectors");
00238                 return NULL;
00239         }
00240         if(self->cb_user) {
00241                 PyErr_SetString(PyExc_TypeError,
00242                                 "vector.resize_4d(): "
00243                                 "cannot resize a vector that has an owner");
00244                 return NULL;
00245         }
00246 
00247         self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 4));
00248         if(self->vec == NULL) {
00249                 PyErr_SetString(PyExc_MemoryError,
00250                                 "vector.resize_4d(): "
00251                                 "problem allocating pointer space");
00252                 return NULL;
00253         }
00254 
00255         if(self->size == 2){
00256                 self->vec[2] = 0.0f;
00257                 self->vec[3] = 1.0f;
00258         }
00259         else if(self->size == 3){
00260                 self->vec[3] = 1.0f;
00261         }
00262         self->size = 4;
00263         Py_RETURN_NONE;
00264 }
00265 PyDoc_STRVAR(Vector_to_2d_doc,
00266 ".. method:: to_2d()\n"
00267 "\n"
00268 "   Return a 2d copy of the vector.\n"
00269 "\n"
00270 "   :return: a new vector\n"
00271 "   :rtype: :class:`Vector`\n"
00272 );
00273 static PyObject *Vector_to_2d(VectorObject *self)
00274 {
00275         if(BaseMath_ReadCallback(self) == -1)
00276                 return NULL;
00277 
00278         return newVectorObject(self->vec, 2, Py_NEW, Py_TYPE(self));
00279 }
00280 PyDoc_STRVAR(Vector_to_3d_doc,
00281 ".. method:: to_3d()\n"
00282 "\n"
00283 "   Return a 3d copy of the vector.\n"
00284 "\n"
00285 "   :return: a new vector\n"
00286 "   :rtype: :class:`Vector`\n"
00287 );
00288 static PyObject *Vector_to_3d(VectorObject *self)
00289 {
00290         float tvec[3]= {0.0f};
00291 
00292         if(BaseMath_ReadCallback(self) == -1)
00293                 return NULL;
00294 
00295         memcpy(tvec, self->vec, sizeof(float) * MIN2(self->size, 3));
00296         return newVectorObject(tvec, 3, Py_NEW, Py_TYPE(self));
00297 }
00298 PyDoc_STRVAR(Vector_to_4d_doc,
00299 ".. method:: to_4d()\n"
00300 "\n"
00301 "   Return a 4d copy of the vector.\n"
00302 "\n"
00303 "   :return: a new vector\n"
00304 "   :rtype: :class:`Vector`\n"
00305 );
00306 static PyObject *Vector_to_4d(VectorObject *self)
00307 {
00308         float tvec[4]= {0.0f, 0.0f, 0.0f, 1.0f};
00309 
00310         if(BaseMath_ReadCallback(self) == -1)
00311                 return NULL;
00312 
00313         memcpy(tvec, self->vec, sizeof(float) * MIN2(self->size, 4));
00314         return newVectorObject(tvec, 4, Py_NEW, Py_TYPE(self));
00315 }
00316 
00317 PyDoc_STRVAR(Vector_to_tuple_doc,
00318 ".. method:: to_tuple(precision=-1)\n"
00319 "\n"
00320 "   Return this vector as a tuple with.\n"
00321 "\n"
00322 "   :arg precision: The number to round the value to in [-1, 21].\n"
00323 "   :type precision: int\n"
00324 "   :return: the values of the vector rounded by *precision*\n"
00325 "   :rtype: tuple\n"
00326 );
00327 /* note: BaseMath_ReadCallback must be called beforehand */
00328 static PyObject *Vector_to_tuple_ext(VectorObject *self, int ndigits)
00329 {
00330         PyObject *ret;
00331         int i;
00332 
00333         ret= PyTuple_New(self->size);
00334 
00335         if(ndigits >= 0) {
00336                 for(i = 0; i < self->size; i++) {
00337                         PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->vec[i], ndigits)));
00338                 }
00339         }
00340         else {
00341                 for(i = 0; i < self->size; i++) {
00342                         PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->vec[i]));
00343                 }
00344         }
00345 
00346         return ret;
00347 }
00348 
00349 static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args)
00350 {
00351         int ndigits= 0;
00352 
00353         if(!PyArg_ParseTuple(args, "|i:to_tuple", &ndigits))
00354                 return NULL;
00355 
00356         if(ndigits > 22 || ndigits < 0) {
00357                 PyErr_SetString(PyExc_ValueError,
00358                                 "vector.to_tuple(ndigits): "
00359                                 "ndigits must be between 0 and 21");
00360                 return NULL;
00361         }
00362 
00363         if(PyTuple_GET_SIZE(args)==0)
00364                 ndigits= -1;
00365 
00366         if(BaseMath_ReadCallback(self) == -1)
00367                 return NULL;
00368 
00369         return Vector_to_tuple_ext(self, ndigits);
00370 }
00371 
00372 PyDoc_STRVAR(Vector_to_track_quat_doc,
00373 ".. method:: to_track_quat(track, up)\n"
00374 "\n"
00375 "   Return a quaternion rotation from the vector and the track and up axis.\n"
00376 "\n"
00377 "   :arg track: Track axis in ['X', 'Y', 'Z', '-X', '-Y', '-Z'].\n"
00378 "   :type track: string\n"
00379 "   :arg up: Up axis in ['X', 'Y', 'Z'].\n"
00380 "   :type up: string\n"
00381 "   :return: rotation from the vector and the track and up axis.\n"
00382 "   :rtype: :class:`Quaternion`\n"
00383 );
00384 static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
00385 {
00386         float vec[3], quat[4];
00387         const char *strack, *sup;
00388         short track = 2, up = 1;
00389 
00390         if(!PyArg_ParseTuple(args, "|ss:to_track_quat", &strack, &sup))
00391                 return NULL;
00392 
00393         if (self->size != 3) {
00394                 PyErr_SetString(PyExc_TypeError,
00395                                 "vector.to_track_quat(): "
00396                                 "only for 3D vectors");
00397                 return NULL;
00398         }
00399 
00400         if(BaseMath_ReadCallback(self) == -1)
00401                 return NULL;
00402 
00403         if (strack) {
00404                 const char *axis_err_msg= "only X, -X, Y, -Y, Z or -Z for track axis";
00405 
00406                 if (strlen(strack) == 2) {
00407                         if (strack[0] == '-') {
00408                                 switch(strack[1]) {
00409                                         case 'X':
00410                                                 track = 3;
00411                                                 break;
00412                                         case 'Y':
00413                                                 track = 4;
00414                                                 break;
00415                                         case 'Z':
00416                                                 track = 5;
00417                                                 break;
00418                                         default:
00419                                                 PyErr_SetString(PyExc_ValueError, axis_err_msg);
00420                                                 return NULL;
00421                                 }
00422                         }
00423                         else {
00424                                 PyErr_SetString(PyExc_ValueError, axis_err_msg);
00425                                 return NULL;
00426                         }
00427                 }
00428                 else if (strlen(strack) == 1) {
00429                         switch(strack[0]) {
00430                         case '-':
00431                         case 'X':
00432                                 track = 0;
00433                                 break;
00434                         case 'Y':
00435                                 track = 1;
00436                                 break;
00437                         case 'Z':
00438                                 track = 2;
00439                                 break;
00440                         default:
00441                                 PyErr_SetString(PyExc_ValueError, axis_err_msg);
00442                                 return NULL;
00443                         }
00444                 }
00445                 else {
00446                         PyErr_SetString(PyExc_ValueError, axis_err_msg);
00447                         return NULL;
00448                 }
00449         }
00450 
00451         if (sup) {
00452                 const char *axis_err_msg= "only X, Y or Z for up axis";
00453                 if (strlen(sup) == 1) {
00454                         switch(*sup) {
00455                         case 'X':
00456                                 up = 0;
00457                                 break;
00458                         case 'Y':
00459                                 up = 1;
00460                                 break;
00461                         case 'Z':
00462                                 up = 2;
00463                                 break;
00464                         default:
00465                                 PyErr_SetString(PyExc_ValueError, axis_err_msg);
00466                                 return NULL;
00467                         }
00468                 }
00469                 else {
00470                         PyErr_SetString(PyExc_ValueError, axis_err_msg);
00471                         return NULL;
00472                 }
00473         }
00474 
00475         if (track == up) {
00476                 PyErr_SetString(PyExc_ValueError,
00477                                 "Can't have the same axis for track and up");
00478                 return NULL;
00479         }
00480 
00481         /*
00482                 flip vector around, since vectoquat expect a vector from target to tracking object
00483                 and the python function expects the inverse (a vector to the target).
00484         */
00485         negate_v3_v3(vec, self->vec);
00486 
00487         vec_to_quat(quat, vec, track, up);
00488 
00489         return newQuaternionObject(quat, Py_NEW, NULL);
00490 }
00491 
00492 /*
00493  * Vector.reflect(mirror): return a reflected vector on the mirror normal
00494  *  vec - ((2 * DotVecs(vec, mirror)) * mirror)
00495  */
00496 PyDoc_STRVAR(Vector_reflect_doc,
00497 ".. method:: reflect(mirror)\n"
00498 "\n"
00499 "   Return the reflection vector from the *mirror* argument.\n"
00500 "\n"
00501 "   :arg mirror: This vector could be a normal from the reflecting surface.\n"
00502 "   :type mirror: :class:`Vector`\n"
00503 "   :return: The reflected vector matching the size of this vector.\n"
00504 "   :rtype: :class:`Vector`\n"
00505 );
00506 static PyObject *Vector_reflect(VectorObject *self, PyObject *value)
00507 {
00508         int value_size;
00509         float mirror[3], vec[3];
00510         float reflect[3] = {0.0f};
00511         float tvec[MAX_DIMENSIONS];
00512 
00513         if(BaseMath_ReadCallback(self) == -1)
00514                 return NULL;
00515 
00516         if((value_size= mathutils_array_parse(tvec, 2, 4, value, "vector.reflect(other), invalid 'other' arg")) == -1)
00517                 return NULL;
00518 
00519         mirror[0] = tvec[0];
00520         mirror[1] = tvec[1];
00521         if (value_size > 2)             mirror[2] = tvec[2];
00522         else                                    mirror[2] = 0.0;
00523 
00524         vec[0] = self->vec[0];
00525         vec[1] = self->vec[1];
00526         if (self->size > 2)             vec[2] = self->vec[2];
00527         else                                    vec[2] = 0.0;
00528 
00529         normalize_v3(mirror);
00530         reflect_v3_v3v3(reflect, vec, mirror);
00531 
00532         return newVectorObject(reflect, self->size, Py_NEW, Py_TYPE(self));
00533 }
00534 
00535 PyDoc_STRVAR(Vector_cross_doc,
00536 ".. method:: cross(other)\n"
00537 "\n"
00538 "   Return the cross product of this vector and another.\n"
00539 "\n"
00540 "   :arg other: The other vector to perform the cross product with.\n"
00541 "   :type other: :class:`Vector`\n"
00542 "   :return: The cross product.\n"
00543 "   :rtype: :class:`Vector`\n"
00544 "\n"
00545 "   .. note:: both vectors must be 3D\n"
00546 );
00547 static PyObject *Vector_cross(VectorObject *self, PyObject *value)
00548 {
00549         VectorObject *ret;
00550         float tvec[MAX_DIMENSIONS];
00551 
00552         if(BaseMath_ReadCallback(self) == -1)
00553                 return NULL;
00554 
00555         if(mathutils_array_parse(tvec, self->size, self->size, value, "vector.cross(other), invalid 'other' arg") == -1)
00556                 return NULL;
00557 
00558         ret= (VectorObject *)newVectorObject(NULL, 3, Py_NEW, Py_TYPE(self));
00559         cross_v3_v3v3(ret->vec, self->vec, tvec);
00560         return (PyObject *)ret;
00561 }
00562 
00563 PyDoc_STRVAR(Vector_dot_doc,
00564 ".. method:: dot(other)\n"
00565 "\n"
00566 "   Return the dot product of this vector and another.\n"
00567 "\n"
00568 "   :arg other: The other vector to perform the dot product with.\n"
00569 "   :type other: :class:`Vector`\n"
00570 "   :return: The dot product.\n"
00571 "   :rtype: :class:`Vector`\n"
00572 );
00573 static PyObject *Vector_dot(VectorObject *self, PyObject *value)
00574 {
00575         float tvec[MAX_DIMENSIONS];
00576         double dot = 0.0;
00577         int x;
00578 
00579         if(BaseMath_ReadCallback(self) == -1)
00580                 return NULL;
00581 
00582         if(mathutils_array_parse(tvec, self->size, self->size, value, "vector.dot(other), invalid 'other' arg") == -1)
00583                 return NULL;
00584 
00585         for(x = 0; x < self->size; x++) {
00586                 dot += (double)(self->vec[x] * tvec[x]);
00587         }
00588 
00589         return PyFloat_FromDouble(dot);
00590 }
00591 
00592 PyDoc_STRVAR(Vector_angle_doc,
00593 ".. function:: angle(other, fallback)\n"
00594 "\n"
00595 "   Return the angle between two vectors.\n"
00596 "\n"
00597 "   :arg other: another vector to compare the angle with\n"
00598 "   :type other: :class:`Vector`\n"
00599 "   :arg fallback: return this value when the angle cant be calculated\n"
00600 "      (zero length vector)\n"
00601 "   :type fallback: any\n"
00602 "   :return: angle in radians or fallback when given\n"
00603 "   :rtype: float\n"
00604 "\n"
00605 "   .. note:: Zero length vectors raise an :exc:`AttributeError`.\n"
00606 );
00607 static PyObject *Vector_angle(VectorObject *self, PyObject *args)
00608 {
00609         const int size= self->size;
00610         float tvec[MAX_DIMENSIONS];
00611         PyObject *value;
00612         double dot = 0.0f, test_v1 = 0.0f, test_v2 = 0.0f;
00613         int x;
00614         PyObject *fallback= NULL;
00615 
00616         if(!PyArg_ParseTuple(args, "O|O:angle", &value, &fallback))
00617                 return NULL;
00618 
00619         if(BaseMath_ReadCallback(self) == -1)
00620                 return NULL;
00621 
00622         if(mathutils_array_parse(tvec, size, size, value, "vector.angle(other), invalid 'other' arg") == -1)
00623                 return NULL;
00624 
00625         for(x = 0; x < size; x++) {
00626                 test_v1 += (double)(self->vec[x] * self->vec[x]);
00627                 test_v2 += (double)(tvec[x] * tvec[x]);
00628         }
00629         if (!test_v1 || !test_v2){
00630                 /* avoid exception */
00631                 if(fallback) {
00632                         Py_INCREF(fallback);
00633                         return fallback;
00634                 }
00635                 else {
00636                         PyErr_SetString(PyExc_ValueError,
00637                                         "vector.angle(other): "
00638                                         "zero length vectors have no valid angle");
00639                         return NULL;
00640                 }
00641         }
00642 
00643         //dot product
00644         for(x = 0; x < self->size; x++) {
00645                 dot += (double)(self->vec[x] * tvec[x]);
00646         }
00647         dot /= (sqrt(test_v1) * sqrt(test_v2));
00648 
00649         return PyFloat_FromDouble(saacos(dot));
00650 }
00651 
00652 PyDoc_STRVAR(Vector_rotation_difference_doc,
00653 ".. function:: difference(other)\n"
00654 "\n"
00655 "   Returns a quaternion representing the rotational difference between this\n"
00656 "   vector and another.\n"
00657 "\n"
00658 "   :arg other: second vector.\n"
00659 "   :type other: :class:`Vector`\n"
00660 "   :return: the rotational difference between the two vectors.\n"
00661 "   :rtype: :class:`Quaternion`\n"
00662 "\n"
00663 "   .. note:: 2D vectors raise an :exc:`AttributeError`.\n"
00664 );
00665 static PyObject *Vector_rotation_difference(VectorObject *self, PyObject *value)
00666 {
00667         float quat[4], vec_a[3], vec_b[3];
00668 
00669         if(self->size < 3) {
00670                 PyErr_SetString(PyExc_ValueError,
00671                                 "vec.difference(value): "
00672                                 "expects both vectors to be size 3 or 4");
00673                 return NULL;
00674         }
00675 
00676         if(BaseMath_ReadCallback(self) == -1)
00677                 return NULL;
00678 
00679         if(mathutils_array_parse(vec_b, 3, MAX_DIMENSIONS, value, "vector.difference(other), invalid 'other' arg") == -1)
00680                 return NULL;
00681 
00682         normalize_v3_v3(vec_a, self->vec);
00683         normalize_v3(vec_b);
00684 
00685         rotation_between_vecs_to_quat(quat, vec_a, vec_b);
00686 
00687         return newQuaternionObject(quat, Py_NEW, NULL);
00688 }
00689 
00690 PyDoc_STRVAR(Vector_project_doc,
00691 ".. function:: project(other)\n"
00692 "\n"
00693 "   Return the projection of this vector onto the *other*.\n"
00694 "\n"
00695 "   :arg other: second vector.\n"
00696 "   :type other: :class:`Vector`\n"
00697 "   :return: the parallel projection vector\n"
00698 "   :rtype: :class:`Vector`\n"
00699 );
00700 static PyObject *Vector_project(VectorObject *self, PyObject *value)
00701 {
00702         const int size= self->size;
00703         float tvec[MAX_DIMENSIONS];
00704         float vec[MAX_DIMENSIONS];
00705         double dot = 0.0f, dot2 = 0.0f;
00706         int x;
00707 
00708         if(BaseMath_ReadCallback(self) == -1)
00709                 return NULL;
00710 
00711         if(mathutils_array_parse(tvec, size, size, value, "vector.project(other), invalid 'other' arg") == -1)
00712                 return NULL;
00713 
00714         if(BaseMath_ReadCallback(self) == -1)
00715                 return NULL;
00716 
00717         //get dot products
00718         for(x = 0; x < size; x++) {
00719                 dot += (double)(self->vec[x] * tvec[x]);
00720                 dot2 += (double)(tvec[x] * tvec[x]);
00721         }
00722         //projection
00723         dot /= dot2;
00724         for(x = 0; x < size; x++) {
00725                 vec[x] = (float)dot * tvec[x];
00726         }
00727         return newVectorObject(vec, size, Py_NEW, Py_TYPE(self));
00728 }
00729 
00730 PyDoc_STRVAR(Vector_lerp_doc,
00731 ".. function:: lerp(other, factor)\n"
00732 "\n"
00733 "   Returns the interpolation of two vectors.\n"
00734 "\n"
00735 "   :arg other: value to interpolate with.\n"
00736 "   :type other: :class:`Vector`\n"
00737 "   :arg factor: The interpolation value in [0.0, 1.0].\n"
00738 "   :type factor: float\n"
00739 "   :return: The interpolated rotation.\n"
00740 "   :rtype: :class:`Vector`\n"
00741 );
00742 static PyObject *Vector_lerp(VectorObject *self, PyObject *args)
00743 {
00744         const int size= self->size;
00745         PyObject *value= NULL;
00746         float fac, ifac;
00747         float tvec[MAX_DIMENSIONS], vec[MAX_DIMENSIONS];
00748         int x;
00749 
00750         if(!PyArg_ParseTuple(args, "Of:lerp", &value, &fac))
00751                 return NULL;
00752 
00753         if(mathutils_array_parse(tvec, size, size, value, "vector.lerp(other), invalid 'other' arg") == -1)
00754                 return NULL;
00755 
00756         if(BaseMath_ReadCallback(self) == -1)
00757                 return NULL;
00758 
00759         ifac= 1.0f - fac;
00760 
00761         for(x = 0; x < size; x++) {
00762                 vec[x] = (ifac * self->vec[x]) + (fac * tvec[x]);
00763         }
00764         return newVectorObject(vec, size, Py_NEW, Py_TYPE(self));
00765 }
00766 
00767 PyDoc_STRVAR(Vector_rotate_doc,
00768 ".. function:: rotate(other)\n"
00769 "\n"
00770 "   Return vector by a rotation value.\n"
00771 "\n"
00772 "   :arg other: rotation component of mathutils value\n"
00773 "   :type other: :class:`Euler`, :class:`Quaternion` or :class:`Matrix`\n"
00774 );
00775 static PyObject *Vector_rotate(VectorObject *self, PyObject *value)
00776 {
00777         float other_rmat[3][3];
00778 
00779         if(BaseMath_ReadCallback(self) == -1)
00780                 return NULL;
00781 
00782         if(mathutils_any_to_rotmat(other_rmat, value, "vector.rotate(value)") == -1)
00783                 return NULL;
00784 
00785         if(self->size < 3) {
00786                 PyErr_SetString(PyExc_ValueError,
00787                                 "Vector must be 3D or 4D");
00788                 return NULL;
00789         }
00790 
00791         mul_m3_v3(other_rmat, self->vec);
00792 
00793         (void)BaseMath_WriteCallback(self);
00794         Py_RETURN_NONE;
00795 }
00796 
00797 PyDoc_STRVAR(Vector_copy_doc,
00798 ".. function:: copy()\n"
00799 "\n"
00800 "   Returns a copy of this vector.\n"
00801 "\n"
00802 "   :return: A copy of the vector.\n"
00803 "   :rtype: :class:`Vector`\n"
00804 "\n"
00805 "   .. note:: use this to get a copy of a wrapped vector with\n"
00806 "      no reference to the original data.\n"
00807 );
00808 static PyObject *Vector_copy(VectorObject *self)
00809 {
00810         if(BaseMath_ReadCallback(self) == -1)
00811                 return NULL;
00812 
00813         return newVectorObject(self->vec, self->size, Py_NEW, Py_TYPE(self));
00814 }
00815 
00816 static PyObject *Vector_repr(VectorObject *self)
00817 {
00818         PyObject *ret, *tuple;
00819 
00820         if(BaseMath_ReadCallback(self) == -1)
00821                 return NULL;
00822 
00823         tuple= Vector_to_tuple_ext(self, -1);
00824         ret= PyUnicode_FromFormat("Vector(%R)", tuple);
00825         Py_DECREF(tuple);
00826         return ret;
00827 }
00828 
00829 /* Sequence Protocol */
00830 /* sequence length len(vector) */
00831 static int Vector_len(VectorObject *self)
00832 {
00833         return self->size;
00834 }
00835 /* sequence accessor (get): vector[index] */
00836 static PyObject *vector_item_internal(VectorObject *self, int i, const int is_attr)
00837 {
00838         if(i<0) i= self->size-i;
00839 
00840         if(i < 0 || i >= self->size) {
00841                 if(is_attr)     {
00842                         PyErr_Format(PyExc_AttributeError,
00843                                      "vector.%c: unavailable on %dd vector",
00844                                      *(((char *)"xyzw") + i), self->size);
00845                 }
00846                 else {
00847                         PyErr_SetString(PyExc_IndexError,
00848                                         "vector[index]: out of range");
00849                 }
00850                 return NULL;
00851         }
00852 
00853         if(BaseMath_ReadIndexCallback(self, i) == -1)
00854                 return NULL;
00855 
00856         return PyFloat_FromDouble(self->vec[i]);
00857 }
00858 
00859 static PyObject *Vector_item(VectorObject *self, int i)
00860 {
00861         return vector_item_internal(self, i, FALSE);
00862 }
00863 /* sequence accessor (set): vector[index] = value */
00864 static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value, const int is_attr)
00865 {
00866         float scalar;
00867         if((scalar=PyFloat_AsDouble(value))==-1.0f && PyErr_Occurred()) { /* parsed item not a number */
00868                 PyErr_SetString(PyExc_TypeError,
00869                                 "vector[index] = x: "
00870                                 "index argument not a number");
00871                 return -1;
00872         }
00873 
00874         if(i<0) i= self->size-i;
00875 
00876         if(i < 0 || i >= self->size){
00877                 if(is_attr) {
00878                         PyErr_Format(PyExc_AttributeError,
00879                                      "vector.%c = x: unavailable on %dd vector",
00880                                      *(((char *)"xyzw") + i), self->size);
00881                 }
00882                 else {
00883                         PyErr_SetString(PyExc_IndexError,
00884                                         "vector[index] = x: "
00885                                         "assignment index out of range");
00886                 }
00887                 return -1;
00888         }
00889         self->vec[i] = scalar;
00890 
00891         if(BaseMath_WriteIndexCallback(self, i) == -1)
00892                 return -1;
00893         return 0;
00894 }
00895 
00896 static int Vector_ass_item(VectorObject *self, int i, PyObject *value)
00897 {
00898         return vector_ass_item_internal(self, i, value, FALSE);
00899 }
00900 
00901 /* sequence slice (get): vector[a:b] */
00902 static PyObject *Vector_slice(VectorObject *self, int begin, int end)
00903 {
00904         PyObject *tuple;
00905         int count;
00906 
00907         if(BaseMath_ReadCallback(self) == -1)
00908                 return NULL;
00909 
00910         CLAMP(begin, 0, self->size);
00911         if (end<0) end= self->size+end+1;
00912         CLAMP(end, 0, self->size);
00913         begin= MIN2(begin, end);
00914 
00915         tuple= PyTuple_New(end - begin);
00916         for(count = begin; count < end; count++) {
00917                 PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->vec[count]));
00918         }
00919 
00920         return tuple;
00921 }
00922 /* sequence slice (set): vector[a:b] = value */
00923 static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *seq)
00924 {
00925         int y, size = 0;
00926         float vec[MAX_DIMENSIONS];
00927 
00928         if(BaseMath_ReadCallback(self) == -1)
00929                 return -1;
00930 
00931         CLAMP(begin, 0, self->size);
00932         CLAMP(end, 0, self->size);
00933         begin = MIN2(begin, end);
00934 
00935         size = (end - begin);
00936         if(mathutils_array_parse(vec, size, size, seq, "vector[begin:end] = [...]") == -1)
00937                 return -1;
00938 
00939         /*parsed well - now set in vector*/
00940         for(y = 0; y < size; y++){
00941                 self->vec[begin + y] = vec[y];
00942         }
00943 
00944         if(BaseMath_WriteCallback(self) == -1)
00945                 return -1;
00946 
00947         return 0;
00948 }
00949 
00950 /* Numeric Protocols */
00951 /* addition: obj + obj */
00952 static PyObject *Vector_add(PyObject *v1, PyObject *v2)
00953 {
00954         VectorObject *vec1 = NULL, *vec2 = NULL;
00955         float vec[MAX_DIMENSIONS];
00956 
00957         if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
00958                 PyErr_SetString(PyExc_AttributeError,
00959                                 "Vector addition: "
00960                                 "arguments not valid for this operation");
00961                 return NULL;
00962         }
00963         vec1 = (VectorObject*)v1;
00964         vec2 = (VectorObject*)v2;
00965 
00966         if(BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1)
00967                 return NULL;
00968 
00969         /*VECTOR + VECTOR*/
00970         if(vec1->size != vec2->size) {
00971                 PyErr_SetString(PyExc_AttributeError,
00972                                 "Vector addition: "
00973                                 "vectors must have the same dimensions for this operation");
00974                 return NULL;
00975         }
00976 
00977         add_vn_vnvn(vec, vec1->vec, vec2->vec, vec1->size);
00978 
00979         return newVectorObject(vec, vec1->size, Py_NEW, Py_TYPE(v1));
00980 }
00981 
00982 /* addition in-place: obj += obj */
00983 static PyObject *Vector_iadd(PyObject *v1, PyObject *v2)
00984 {
00985         VectorObject *vec1 = NULL, *vec2 = NULL;
00986 
00987         if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
00988                 PyErr_SetString(PyExc_AttributeError,
00989                                 "Vector addition: "
00990                                 "arguments not valid for this operation");
00991                 return NULL;
00992         }
00993         vec1 = (VectorObject*)v1;
00994         vec2 = (VectorObject*)v2;
00995 
00996         if(vec1->size != vec2->size) {
00997                 PyErr_SetString(PyExc_AttributeError,
00998                                 "Vector addition: "
00999                                 "vectors must have the same dimensions for this operation");
01000                 return NULL;
01001         }
01002 
01003         if(BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1)
01004                 return NULL;
01005 
01006         add_vn_vn(vec1->vec, vec2->vec, vec1->size);
01007 
01008         (void)BaseMath_WriteCallback(vec1);
01009         Py_INCREF(v1);
01010         return v1;
01011 }
01012 
01013 /* subtraction: obj - obj */
01014 static PyObject *Vector_sub(PyObject *v1, PyObject *v2)
01015 {
01016         VectorObject *vec1 = NULL, *vec2 = NULL;
01017         float vec[MAX_DIMENSIONS];
01018 
01019         if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
01020                 PyErr_SetString(PyExc_AttributeError,
01021                                 "Vector subtraction: "
01022                                 "arguments not valid for this operation");
01023                 return NULL;
01024         }
01025         vec1 = (VectorObject*)v1;
01026         vec2 = (VectorObject*)v2;
01027 
01028         if(BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1)
01029                 return NULL;
01030 
01031         if(vec1->size != vec2->size) {
01032                 PyErr_SetString(PyExc_AttributeError,
01033                                 "Vector subtraction: "
01034                                 "vectors must have the same dimensions for this operation");
01035                 return NULL;
01036         }
01037 
01038         sub_vn_vnvn(vec, vec1->vec, vec2->vec, vec1->size);
01039 
01040         return newVectorObject(vec, vec1->size, Py_NEW, Py_TYPE(v1));
01041 }
01042 
01043 /* subtraction in-place: obj -= obj */
01044 static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
01045 {
01046         VectorObject *vec1= NULL, *vec2= NULL;
01047 
01048         if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
01049                 PyErr_SetString(PyExc_AttributeError,
01050                                 "Vector subtraction: "
01051                                 "arguments not valid for this operation");
01052                 return NULL;
01053         }
01054         vec1 = (VectorObject*)v1;
01055         vec2 = (VectorObject*)v2;
01056 
01057         if(vec1->size != vec2->size) {
01058                 PyErr_SetString(PyExc_AttributeError,
01059                                 "Vector subtraction: "
01060                                 "vectors must have the same dimensions for this operation");
01061                 return NULL;
01062         }
01063 
01064         if(BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1)
01065                 return NULL;
01066 
01067         sub_vn_vn(vec1->vec, vec2->vec, vec1->size);
01068 
01069         (void)BaseMath_WriteCallback(vec1);
01070         Py_INCREF(v1);
01071         return v1;
01072 }
01073 
01074 /*------------------------obj * obj------------------------------
01075   mulplication*/
01076 
01077 
01078 /* COLUMN VECTOR Multiplication (Vector X Matrix)
01079  * [a] * [1][4][7]
01080  * [b] * [2][5][8]
01081  * [c] * [3][6][9]
01082  *
01083  * note: vector/matrix multiplication IS NOT COMMUTATIVE!!!!
01084  * note: assume read callbacks have been done first.
01085  */
01086 int column_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject* vec, MatrixObject * mat)
01087 {
01088         float vec_cpy[MAX_DIMENSIONS];
01089         double dot = 0.0f;
01090         int x, y, z = 0;
01091 
01092         if(mat->row_size != vec->size){
01093                 if(mat->row_size == 4 && vec->size == 3) {
01094                         vec_cpy[3] = 1.0f;
01095                 }
01096                 else {
01097                         PyErr_SetString(PyExc_TypeError,
01098                                         "matrix * vector: "
01099                                         "matrix.row_size and len(vector) must be the same, "
01100                                         "except for 3D vector * 4x4 matrix.");
01101                         return -1;
01102                 }
01103         }
01104 
01105         memcpy(vec_cpy, vec->vec, vec->size * sizeof(float));
01106 
01107         rvec[3] = 1.0f;
01108 
01109         for(x = 0; x < mat->col_size; x++) {
01110                 for(y = 0; y < mat->row_size; y++) {
01111                         dot += (double)(mat->matrix[y][x] * vec_cpy[y]);
01112                 }
01113                 rvec[z++] = (float)dot;
01114                 dot = 0.0f;
01115         }
01116 
01117         return 0;
01118 }
01119 
01120 static PyObject *vector_mul_float(VectorObject *vec, const float scalar)
01121 {
01122         float tvec[MAX_DIMENSIONS];
01123         mul_vn_vn_fl(tvec, vec->vec, vec->size, scalar);
01124         return newVectorObject(tvec, vec->size, Py_NEW, Py_TYPE(vec));
01125 }
01126 
01127 static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
01128 {
01129         VectorObject *vec1 = NULL, *vec2 = NULL;
01130         float scalar;
01131 
01132         if VectorObject_Check(v1) {
01133                 vec1= (VectorObject *)v1;
01134                 if(BaseMath_ReadCallback(vec1) == -1)
01135                         return NULL;
01136         }
01137         if VectorObject_Check(v2) {
01138                 vec2= (VectorObject *)v2;
01139                 if(BaseMath_ReadCallback(vec2) == -1)
01140                         return NULL;
01141         }
01142 
01143 
01144         /* make sure v1 is always the vector */
01145         if (vec1 && vec2) {
01146                 int i;
01147                 double dot = 0.0f;
01148 
01149                 if(vec1->size != vec2->size) {
01150                         PyErr_SetString(PyExc_ValueError,
01151                                         "Vector multiplication: "
01152                                         "vectors must have the same dimensions for this operation");
01153                         return NULL;
01154                 }
01155 
01156                 /*dot product*/
01157                 for(i = 0; i < vec1->size; i++) {
01158                         dot += (double)(vec1->vec[i] * vec2->vec[i]);
01159                 }
01160                 return PyFloat_FromDouble(dot);
01161         }
01162         else if (vec1) {
01163                 if (MatrixObject_Check(v2)) {
01164                         extern void PyC_LineSpit(void);
01165 
01166                         /* VEC * MATRIX */
01167                         /* this is deprecated!, use the reverse instead */
01168                         float tvec[MAX_DIMENSIONS];
01169 
01170 
01171 /* ------ to be removed ------*/
01172 #ifndef MATH_STANDALONE
01173 #ifdef WITH_ASSERT_ABORT
01174                         PyErr_SetString(PyExc_ValueError,
01175                                         "(Vector * Matrix) is now removed, reverse the "
01176                                         "order (promoted to an Error for Debug builds)");
01177                         return NULL;
01178 #else
01179                         printf("Warning: (Vector * Matrix) is now deprecated, "
01180                                "reverse the multiplication order in the script.\n");
01181                         PyC_LineSpit();
01182 #endif
01183 #endif          /* ifndef MATH_STANDALONE */
01184 /* ------ to be removed ------*/
01185 
01186 
01187                         if(BaseMath_ReadCallback((MatrixObject *)v2) == -1)
01188                                 return NULL;
01189                         if(column_vector_multiplication(tvec, vec1, (MatrixObject*)v2) == -1) {
01190                                 return NULL;
01191                         }
01192 
01193                         return newVectorObject(tvec, vec1->size, Py_NEW, Py_TYPE(vec1));
01194                 }
01195                 else if (QuaternionObject_Check(v2)) {
01196                         /* VEC * QUAT */
01197                         QuaternionObject *quat2 = (QuaternionObject*)v2;
01198                         float tvec[3];
01199 
01200                         if(vec1->size != 3) {
01201                                 PyErr_SetString(PyExc_ValueError,
01202                                                 "Vector multiplication: "
01203                                                 "only 3D vector rotations (with quats) currently supported");
01204                                 return NULL;
01205                         }
01206                         if(BaseMath_ReadCallback(quat2) == -1) {
01207                                 return NULL;
01208                         }
01209 
01210 
01211 /* ------ to be removed ------*/
01212 #ifndef MATH_STANDALONE
01213 #ifdef WITH_ASSERT_ABORT
01214                         PyErr_SetString(PyExc_ValueError,
01215                                         "(Vector * Quat) is now removed, reverse the "
01216                                         "order (promoted to an Error for Debug builds)");
01217                         return NULL;
01218 #else
01219                         printf("Warning: (Vector * Quat) is now deprecated, "
01220                                "reverse the multiplication order in the script.\n");
01221                         PyC_LineSpit();
01222 #endif
01223 #endif          /* ifndef MATH_STANDALONE */
01224 /* ------ to be removed ------*/
01225 
01226 
01227                         copy_v3_v3(tvec, vec1->vec);
01228                         mul_qt_v3(quat2->quat, tvec);
01229                         return newVectorObject(tvec, 3, Py_NEW, Py_TYPE(vec1));
01230                 }
01231                 else if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* VEC * FLOAT */
01232                         return vector_mul_float(vec1, scalar);
01233                 }
01234         }
01235         else if (vec2) {
01236                 if (((scalar= PyFloat_AsDouble(v1)) == -1.0f && PyErr_Occurred())==0) { /* FLOAT * VEC */
01237                         return vector_mul_float(vec2, scalar);
01238                 }
01239         }
01240         else {
01241                 BLI_assert(!"internal error");
01242         }
01243 
01244         PyErr_Format(PyExc_TypeError,
01245                      "Vector multiplication: "
01246                      "not supported between '%.200s' and '%.200s' types",
01247                      Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
01248         return NULL;
01249 }
01250 
01251 /* mulplication in-place: obj *= obj */
01252 static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
01253 {
01254         VectorObject *vec = (VectorObject *)v1;
01255         float scalar;
01256 
01257         if(BaseMath_ReadCallback(vec) == -1)
01258                 return NULL;
01259 
01260         /* only support vec*=float and vec*=mat
01261            vec*=vec result is a float so that wont work */
01262         if (MatrixObject_Check(v2)) {
01263                 float rvec[MAX_DIMENSIONS];
01264                 if(BaseMath_ReadCallback((MatrixObject *)v2) == -1)
01265                         return NULL;
01266 
01267                 if(column_vector_multiplication(rvec, vec, (MatrixObject*)v2) == -1)
01268                         return NULL;
01269 
01270 
01271 /* ------ to be removed ------*/
01272 #ifndef MATH_STANDALONE
01273 #ifdef WITH_ASSERT_ABORT
01274                         PyErr_SetString(PyExc_ValueError,
01275                                                         "(Vector *= Matrix) is now removed, reverse the "
01276                                                         "order (promoted to an Error for Debug builds) "
01277                                         "and uses the non in-place multiplication.");
01278                         return NULL;
01279 #else
01280                         printf("Warning: (Vector *= Matrix) is now deprecated, "
01281                                    "reverse the (non in-place) multiplication order in the script.\n");
01282                         PyC_LineSpit();
01283 #endif
01284 #endif          /* ifndef MATH_STANDALONE */
01285 /* ------ to be removed ------*/
01286 
01287 
01288                 memcpy(vec->vec, rvec, sizeof(float) * vec->size);
01289         }
01290         else if (QuaternionObject_Check(v2)) {
01291                 /* VEC *= QUAT */
01292                 QuaternionObject *quat2 = (QuaternionObject*)v2;
01293 
01294                 if(vec->size != 3) {
01295                         PyErr_SetString(PyExc_ValueError,
01296                                         "Vector multiplication: "
01297                                         "only 3D vector rotations (with quats) currently supported");
01298                         return NULL;
01299                 }
01300 
01301                 if(BaseMath_ReadCallback(quat2) == -1) {
01302                         return NULL;
01303                 }
01304 
01305 
01306 /* ------ to be removed ------*/
01307 #ifndef MATH_STANDALONE
01308 #ifdef WITH_ASSERT_ABORT
01309                         PyErr_SetString(PyExc_ValueError,
01310                                                         "(Vector *= Quat) is now removed, reverse the "
01311                                                         "order (promoted to an Error for Debug builds) "
01312                                         "and uses the non in-place multiplication.");
01313                         return NULL;
01314 #else
01315                         printf("Warning: (Vector *= Quat) is now deprecated, "
01316                                    "reverse the (non in-place) multiplication order in the script.\n");
01317                         PyC_LineSpit();
01318 #endif
01319 #endif          /* ifndef MATH_STANDALONE */
01320 /* ------ to be removed ------*/
01321 
01322 
01323                 mul_qt_v3(quat2->quat, vec->vec);
01324         }
01325         else if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* VEC *= FLOAT */
01326                 mul_vn_fl(vec->vec, vec->size, scalar);
01327         }
01328         else {
01329                 PyErr_SetString(PyExc_TypeError,
01330                                 "Vector multiplication: "
01331                                 "arguments not acceptable for this operation");
01332                 return NULL;
01333         }
01334 
01335         (void)BaseMath_WriteCallback(vec);
01336         Py_INCREF(v1);
01337         return v1;
01338 }
01339 
01340 /* divid: obj / obj */
01341 static PyObject *Vector_div(PyObject *v1, PyObject *v2)
01342 {
01343         int i;
01344         float vec[4], scalar;
01345         VectorObject *vec1 = NULL;
01346 
01347         if(!VectorObject_Check(v1)) { /* not a vector */
01348                 PyErr_SetString(PyExc_TypeError,
01349                                 "Vector division: "
01350                                 "Vector must be divided by a float");
01351                 return NULL;
01352         }
01353         vec1 = (VectorObject*)v1; /* vector */
01354 
01355         if(BaseMath_ReadCallback(vec1) == -1)
01356                 return NULL;
01357 
01358         if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
01359                 PyErr_SetString(PyExc_TypeError,
01360                                 "Vector division: "
01361                                 "Vector must be divided by a float");
01362                 return NULL;
01363         }
01364 
01365         if(scalar==0.0f) {
01366                 PyErr_SetString(PyExc_ZeroDivisionError,
01367                                 "Vector division: "
01368                                 "divide by zero error");
01369                 return NULL;
01370         }
01371 
01372         for(i = 0; i < vec1->size; i++) {
01373                 vec[i] = vec1->vec[i] / scalar;
01374         }
01375         return newVectorObject(vec, vec1->size, Py_NEW, Py_TYPE(v1));
01376 }
01377 
01378 /* divide in-place: obj /= obj */
01379 static PyObject *Vector_idiv(PyObject *v1, PyObject *v2)
01380 {
01381         int i;
01382         float scalar;
01383         VectorObject *vec1 = (VectorObject*)v1;
01384 
01385         if(BaseMath_ReadCallback(vec1) == -1)
01386                 return NULL;
01387 
01388         if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
01389                 PyErr_SetString(PyExc_TypeError,
01390                                 "Vector division: "
01391                                 "Vector must be divided by a float");
01392                 return NULL;
01393         }
01394 
01395         if(scalar==0.0f) {
01396                 PyErr_SetString(PyExc_ZeroDivisionError,
01397                                 "Vector division: "
01398                                 "divide by zero error");
01399                 return NULL;
01400         }
01401         for(i = 0; i < vec1->size; i++) {
01402                 vec1->vec[i] /= scalar;
01403         }
01404 
01405         (void)BaseMath_WriteCallback(vec1);
01406 
01407         Py_INCREF(v1);
01408         return v1;
01409 }
01410 
01411 /* -obj
01412   returns the negative of this object*/
01413 static PyObject *Vector_neg(VectorObject *self)
01414 {
01415         float tvec[MAX_DIMENSIONS];
01416 
01417         if(BaseMath_ReadCallback(self) == -1)
01418                 return NULL;
01419 
01420         negate_vn_vn(tvec, self->vec, self->size);
01421         return newVectorObject(tvec, self->size, Py_NEW, Py_TYPE(self));
01422 }
01423 
01424 /*------------------------vec_magnitude_nosqrt (internal) - for comparing only */
01425 static double vec_magnitude_nosqrt(float *data, int size)
01426 {
01427         double dot = 0.0f;
01428         int i;
01429 
01430         for(i=0; i<size; i++){
01431                 dot += (double)data[i];
01432         }
01433         /*return (double)sqrt(dot);*/
01434         /* warning, line above removed because we are not using the length,
01435            rather the comparing the sizes and for this we do not need the sqrt
01436            for the actual length, the dot must be sqrt'd */
01437         return dot;
01438 }
01439 
01440 
01441 /*------------------------tp_richcmpr
01442   returns -1 execption, 0 false, 1 true */
01443 static PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_type)
01444 {
01445         VectorObject *vecA = NULL, *vecB = NULL;
01446         int result = 0;
01447         double epsilon = .000001f;
01448         double lenA, lenB;
01449 
01450         if (!VectorObject_Check(objectA) || !VectorObject_Check(objectB)){
01451                 if (comparison_type == Py_NE){
01452                         Py_RETURN_TRUE;
01453                 }
01454                 else {
01455                         Py_RETURN_FALSE;
01456                 }
01457         }
01458         vecA = (VectorObject*)objectA;
01459         vecB = (VectorObject*)objectB;
01460 
01461         if(BaseMath_ReadCallback(vecA) == -1 || BaseMath_ReadCallback(vecB) == -1)
01462                 return NULL;
01463 
01464         if (vecA->size != vecB->size){
01465                 if (comparison_type == Py_NE){
01466                         Py_RETURN_TRUE;
01467                 }
01468                 else {
01469                         Py_RETURN_FALSE;
01470                 }
01471         }
01472 
01473         switch (comparison_type){
01474                 case Py_LT:
01475                         lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
01476                         lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
01477                         if(lenA < lenB){
01478                                 result = 1;
01479                         }
01480                         break;
01481                 case Py_LE:
01482                         lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
01483                         lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
01484                         if(lenA < lenB){
01485                                 result = 1;
01486                         }
01487                         else {
01488                                 result = (((lenA + epsilon) > lenB) && ((lenA - epsilon) < lenB));
01489                         }
01490                         break;
01491                 case Py_EQ:
01492                         result = EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->size, 1);
01493                         break;
01494                 case Py_NE:
01495                         result = !EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->size, 1);
01496                         break;
01497                 case Py_GT:
01498                         lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
01499                         lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
01500                         if(lenA > lenB){
01501                                 result = 1;
01502                         }
01503                         break;
01504                 case Py_GE:
01505                         lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
01506                         lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
01507                         if(lenA > lenB){
01508                                 result = 1;
01509                         }
01510                         else {
01511                                 result = (((lenA + epsilon) > lenB) && ((lenA - epsilon) < lenB));
01512                         }
01513                         break;
01514                 default:
01515                         printf("The result of the comparison could not be evaluated");
01516                         break;
01517         }
01518         if (result == 1){
01519                 Py_RETURN_TRUE;
01520         }
01521         else {
01522                 Py_RETURN_FALSE;
01523         }
01524 }
01525 
01526 /*-----------------PROTCOL DECLARATIONS--------------------------*/
01527 static PySequenceMethods Vector_SeqMethods = {
01528         (lenfunc) Vector_len,                           /* sq_length */
01529         (binaryfunc) NULL,                                      /* sq_concat */
01530         (ssizeargfunc) NULL,                            /* sq_repeat */
01531         (ssizeargfunc) Vector_item,                     /* sq_item */
01532         NULL,                                                           /* py3 deprecated slice func */
01533         (ssizeobjargproc) Vector_ass_item,      /* sq_ass_item */
01534         NULL,                                                           /* py3 deprecated slice assign func */
01535         (objobjproc) NULL,                                      /* sq_contains */
01536         (binaryfunc) NULL,                                      /* sq_inplace_concat */
01537         (ssizeargfunc) NULL,                            /* sq_inplace_repeat */
01538 };
01539 
01540 static PyObject *Vector_subscript(VectorObject* self, PyObject* item)
01541 {
01542         if (PyIndex_Check(item)) {
01543                 Py_ssize_t i;
01544                 i = PyNumber_AsSsize_t(item, PyExc_IndexError);
01545                 if (i == -1 && PyErr_Occurred())
01546                         return NULL;
01547                 if (i < 0)
01548                         i += self->size;
01549                 return Vector_item(self, i);
01550         }
01551         else if (PySlice_Check(item)) {
01552                 Py_ssize_t start, stop, step, slicelength;
01553 
01554                 if (PySlice_GetIndicesEx((void *)item, self->size, &start, &stop, &step, &slicelength) < 0)
01555                         return NULL;
01556 
01557                 if (slicelength <= 0) {
01558                         return PyTuple_New(0);
01559                 }
01560                 else if (step == 1) {
01561                         return Vector_slice(self, start, stop);
01562                 }
01563                 else {
01564                         PyErr_SetString(PyExc_IndexError,
01565                                         "slice steps not supported with vectors");
01566                         return NULL;
01567                 }
01568         }
01569         else {
01570                 PyErr_Format(PyExc_TypeError,
01571                              "vector indices must be integers, not %.200s",
01572                              Py_TYPE(item)->tp_name);
01573                 return NULL;
01574         }
01575 }
01576 
01577 static int Vector_ass_subscript(VectorObject* self, PyObject* item, PyObject* value)
01578 {
01579         if (PyIndex_Check(item)) {
01580                 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
01581                 if (i == -1 && PyErr_Occurred())
01582                         return -1;
01583                 if (i < 0)
01584                         i += self->size;
01585                 return Vector_ass_item(self, i, value);
01586         }
01587         else if (PySlice_Check(item)) {
01588                 Py_ssize_t start, stop, step, slicelength;
01589 
01590                 if (PySlice_GetIndicesEx((void *)item, self->size, &start, &stop, &step, &slicelength) < 0)
01591                         return -1;
01592 
01593                 if (step == 1)
01594                         return Vector_ass_slice(self, start, stop, value);
01595                 else {
01596                         PyErr_SetString(PyExc_IndexError,
01597                                         "slice steps not supported with vectors");
01598                         return -1;
01599                 }
01600         }
01601         else {
01602                 PyErr_Format(PyExc_TypeError,
01603                              "vector indices must be integers, not %.200s",
01604                              Py_TYPE(item)->tp_name);
01605                 return -1;
01606         }
01607 }
01608 
01609 static PyMappingMethods Vector_AsMapping = {
01610         (lenfunc)Vector_len,
01611         (binaryfunc)Vector_subscript,
01612         (objobjargproc)Vector_ass_subscript
01613 };
01614 
01615 
01616 static PyNumberMethods Vector_NumMethods = {
01617         (binaryfunc)    Vector_add,     /*nb_add*/
01618         (binaryfunc)    Vector_sub,     /*nb_subtract*/
01619         (binaryfunc)    Vector_mul,     /*nb_multiply*/
01620         NULL,                                                   /*nb_remainder*/
01621         NULL,                                                   /*nb_divmod*/
01622         NULL,                                                   /*nb_power*/
01623         (unaryfunc)     Vector_neg,     /*nb_negative*/
01624         (unaryfunc)     NULL,   /*tp_positive*/
01625         (unaryfunc)     NULL,   /*tp_absolute*/
01626         (inquiry)       NULL,   /*tp_bool*/
01627         (unaryfunc)     NULL,   /*nb_invert*/
01628         NULL,                           /*nb_lshift*/
01629         (binaryfunc)NULL,       /*nb_rshift*/
01630         NULL,                           /*nb_and*/
01631         NULL,                           /*nb_xor*/
01632         NULL,                           /*nb_or*/
01633         NULL,                           /*nb_int*/
01634         NULL,                           /*nb_reserved*/
01635         NULL,                           /*nb_float*/
01636         Vector_iadd,    /* nb_inplace_add */
01637         Vector_isub,    /* nb_inplace_subtract */
01638         Vector_imul,    /* nb_inplace_multiply */
01639         NULL,                           /* nb_inplace_remainder */
01640         NULL,                           /* nb_inplace_power */
01641         NULL,                           /* nb_inplace_lshift */
01642         NULL,                           /* nb_inplace_rshift */
01643         NULL,                           /* nb_inplace_and */
01644         NULL,                           /* nb_inplace_xor */
01645         NULL,                           /* nb_inplace_or */
01646         NULL,                           /* nb_floor_divide */
01647         Vector_div,             /* nb_true_divide */
01648         NULL,                           /* nb_inplace_floor_divide */
01649         Vector_idiv,    /* nb_inplace_true_divide */
01650         NULL,                   /* nb_index */
01651 };
01652 
01653 /*------------------PY_OBECT DEFINITION--------------------------*/
01654 
01655 /*
01656  * vector axis, vector.x/y/z/w
01657  */
01658 
01659 static PyObject *Vector_getAxis(VectorObject *self, void *type)
01660 {
01661         return vector_item_internal(self, GET_INT_FROM_POINTER(type), TRUE);
01662 }
01663 
01664 static int Vector_setAxis(VectorObject *self, PyObject *value, void *type)
01665 {
01666         return vector_ass_item_internal(self, GET_INT_FROM_POINTER(type), value, TRUE);
01667 }
01668 
01669 /* vector.length */
01670 static PyObject *Vector_getLength(VectorObject *self, void *UNUSED(closure))
01671 {
01672         double dot = 0.0f;
01673         int i;
01674 
01675         if(BaseMath_ReadCallback(self) == -1)
01676                 return NULL;
01677 
01678         for(i = 0; i < self->size; i++){
01679                 dot += (double)(self->vec[i] * self->vec[i]);
01680         }
01681         return PyFloat_FromDouble(sqrt(dot));
01682 }
01683 
01684 static int Vector_setLength(VectorObject *self, PyObject *value)
01685 {
01686         double dot = 0.0f, param;
01687         int i;
01688 
01689         if(BaseMath_ReadCallback(self) == -1)
01690                 return -1;
01691 
01692         if((param=PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) {
01693                 PyErr_SetString(PyExc_TypeError,
01694                                 "length must be set to a number");
01695                 return -1;
01696         }
01697 
01698         if (param < 0.0) {
01699                 PyErr_SetString(PyExc_ValueError,
01700                                 "cannot set a vectors length to a negative value");
01701                 return -1;
01702         }
01703         if (param == 0.0) {
01704                 fill_vn(self->vec, self->size, 0.0f);
01705                 return 0;
01706         }
01707 
01708         for(i = 0; i < self->size; i++){
01709                 dot += (double)(self->vec[i] * self->vec[i]);
01710         }
01711 
01712         if (!dot) /* cant sqrt zero */
01713                 return 0;
01714 
01715         dot = sqrt(dot);
01716 
01717         if (dot==param)
01718                 return 0;
01719 
01720         dot= dot/param;
01721 
01722         for(i = 0; i < self->size; i++){
01723                 self->vec[i]= self->vec[i] / (float)dot;
01724         }
01725 
01726         (void)BaseMath_WriteCallback(self); /* checked already */
01727 
01728         return 0;
01729 }
01730 
01731 /* vector.length_squared */
01732 static PyObject *Vector_getLengthSquared(VectorObject *self, void *UNUSED(closure))
01733 {
01734         double dot = 0.0f;
01735         int i;
01736 
01737         if(BaseMath_ReadCallback(self) == -1)
01738                 return NULL;
01739 
01740         for(i = 0; i < self->size; i++){
01741                 dot += (double)(self->vec[i] * self->vec[i]);
01742         }
01743         return PyFloat_FromDouble(dot);
01744 }
01745 
01746 /* Get a new Vector according to the provided swizzle. This function has little
01747    error checking, as we are in control of the inputs: the closure is set by us
01748    in Vector_createSwizzleGetSeter. */
01749 static PyObject *Vector_getSwizzle(VectorObject *self, void *closure)
01750 {
01751         size_t axis_to;
01752         size_t axis_from;
01753         float vec[MAX_DIMENSIONS];
01754         unsigned int swizzleClosure;
01755 
01756         if(BaseMath_ReadCallback(self) == -1)
01757                 return NULL;
01758 
01759         /* Unpack the axes from the closure into an array. */
01760         axis_to = 0;
01761         swizzleClosure = GET_INT_FROM_POINTER(closure);
01762         while (swizzleClosure & SWIZZLE_VALID_AXIS)
01763         {
01764                 axis_from = swizzleClosure & SWIZZLE_AXIS;
01765                 if(axis_from >= self->size) {
01766                         PyErr_SetString(PyExc_AttributeError,
01767                                         "Vector swizzle: "
01768                                         "specified axis not present");
01769                         return NULL;
01770                 }
01771 
01772                 vec[axis_to] = self->vec[axis_from];
01773                 swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
01774                 axis_to++;
01775         }
01776 
01777         return newVectorObject(vec, axis_to, Py_NEW, Py_TYPE(self));
01778 }
01779 
01780 /* Set the items of this vector using a swizzle.
01781    - If value is a vector or list this operates like an array copy, except that
01782          the destination is effectively re-ordered as defined by the swizzle. At
01783          most min(len(source), len(dest)) values will be copied.
01784    - If the value is scalar, it is copied to all axes listed in the swizzle.
01785    - If an axis appears more than once in the swizzle, the final occurrence is
01786          the one that determines its value.
01787 
01788    Returns 0 on success and -1 on failure. On failure, the vector will be
01789    unchanged. */
01790 static int Vector_setSwizzle(VectorObject *self, PyObject *value, void *closure)
01791 {
01792         size_t size_from;
01793         float scalarVal;
01794 
01795         size_t axis_from;
01796         size_t axis_to;
01797 
01798         unsigned int swizzleClosure;
01799 
01800         float tvec[MAX_DIMENSIONS];
01801         float vec_assign[MAX_DIMENSIONS];
01802 
01803         if(BaseMath_ReadCallback(self) == -1)
01804                 return -1;
01805 
01806         /* Check that the closure can be used with this vector: even 2D vectors have
01807            swizzles defined for axes z and w, but they would be invalid. */
01808         swizzleClosure = GET_INT_FROM_POINTER(closure);
01809         axis_from= 0;
01810         while (swizzleClosure & SWIZZLE_VALID_AXIS) {
01811                 axis_to = swizzleClosure & SWIZZLE_AXIS;
01812                 if (axis_to >= self->size)
01813                 {
01814                         PyErr_SetString(PyExc_AttributeError,
01815                                         "Vector swizzle: "
01816                                         "specified axis not present");
01817                         return -1;
01818                 }
01819                 swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
01820                 axis_from++;
01821         }
01822 
01823         if (((scalarVal=PyFloat_AsDouble(value)) == -1 && PyErr_Occurred())==0) {
01824                 int i;
01825                 for(i=0; i < MAX_DIMENSIONS; i++)
01826                         vec_assign[i]= scalarVal;
01827 
01828                 size_from= axis_from;
01829         }
01830         else if(PyErr_Clear(), (size_from=mathutils_array_parse(vec_assign, 2, 4, value, "mathutils.Vector.**** = swizzle assignment")) == -1) {
01831                 return -1;
01832         }
01833 
01834         if(axis_from != size_from) {
01835                 PyErr_SetString(PyExc_AttributeError,
01836                                 "Vector swizzle: size does not match swizzle");
01837                 return -1;
01838         }
01839 
01840         /* Copy vector contents onto swizzled axes. */
01841         axis_from = 0;
01842         swizzleClosure = GET_INT_FROM_POINTER(closure);
01843         while (swizzleClosure & SWIZZLE_VALID_AXIS)
01844         {
01845                 axis_to = swizzleClosure & SWIZZLE_AXIS;
01846                 tvec[axis_to] = vec_assign[axis_from];
01847                 swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
01848                 axis_from++;
01849         }
01850 
01851         memcpy(self->vec, tvec, axis_from * sizeof(float));
01852         /* continue with BaseMathObject_WriteCallback at the end */
01853 
01854         if(BaseMath_WriteCallback(self) == -1)
01855                 return -1;
01856         else
01857                 return 0;
01858 }
01859 
01860 /*****************************************************************************/
01861 /* Python attributes get/set structure:                                      */
01862 /*****************************************************************************/
01863 static PyGetSetDef Vector_getseters[] = {
01864         {(char *)"x", (getter)Vector_getAxis, (setter)Vector_setAxis, (char *)"Vector X axis.\n\n:type: float", (void *)0},
01865         {(char *)"y", (getter)Vector_getAxis, (setter)Vector_setAxis, (char *)"Vector Y axis.\n\n:type: float", (void *)1},
01866         {(char *)"z", (getter)Vector_getAxis, (setter)Vector_setAxis, (char *)"Vector Z axis (3D Vectors only).\n\n:type: float", (void *)2},
01867         {(char *)"w", (getter)Vector_getAxis, (setter)Vector_setAxis, (char *)"Vector W axis (4D Vectors only).\n\n:type: float", (void *)3},
01868         {(char *)"length", (getter)Vector_getLength, (setter)Vector_setLength, (char *)"Vector Length.\n\n:type: float", NULL},
01869         {(char *)"length_squared", (getter)Vector_getLengthSquared, (setter)NULL, (char *)"Vector length squared (v.dot(v)).\n\n:type: float", NULL},
01870         {(char *)"magnitude", (getter)Vector_getLength, (setter)Vector_setLength, (char *)"Vector Length.\n\n:type: float", NULL},
01871         {(char *)"is_wrapped", (getter)BaseMathObject_getWrapped, (setter)NULL, (char *)BaseMathObject_Wrapped_doc, NULL},
01872         {(char *)"owner", (getter)BaseMathObject_getOwner, (setter)NULL, (char *)BaseMathObject_Owner_doc, NULL},
01873 
01874         /* autogenerated swizzle attrs, see python script below */
01875         {(char *)"xx",   (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 36
01876         {(char *)"xxx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 292
01877         {(char *)"xxxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2340
01878         {(char *)"xxxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2852
01879         {(char *)"xxxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3364
01880         {(char *)"xxxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3876
01881         {(char *)"xxy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 356
01882         {(char *)"xxyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2404
01883         {(char *)"xxyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2916
01884         {(char *)"xxyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3428
01885         {(char *)"xxyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3940
01886         {(char *)"xxz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 420
01887         {(char *)"xxzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2468
01888         {(char *)"xxzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2980
01889         {(char *)"xxzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3492
01890         {(char *)"xxzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4004
01891         {(char *)"xxw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 484
01892         {(char *)"xxwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2532
01893         {(char *)"xxwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3044
01894         {(char *)"xxwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3556
01895         {(char *)"xxww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4068
01896         {(char *)"xy",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 44
01897         {(char *)"xyx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 300
01898         {(char *)"xyxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2348
01899         {(char *)"xyxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2860
01900         {(char *)"xyxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3372
01901         {(char *)"xyxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3884
01902         {(char *)"xyy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 364
01903         {(char *)"xyyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2412
01904         {(char *)"xyyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2924
01905         {(char *)"xyyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3436
01906         {(char *)"xyyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3948
01907         {(char *)"xyz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 428
01908         {(char *)"xyzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2476
01909         {(char *)"xyzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2988
01910         {(char *)"xyzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3500
01911         {(char *)"xyzw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4012
01912         {(char *)"xyw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 492
01913         {(char *)"xywx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2540
01914         {(char *)"xywy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3052
01915         {(char *)"xywz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3564
01916         {(char *)"xyww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4076
01917         {(char *)"xz",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 52
01918         {(char *)"xzx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 308
01919         {(char *)"xzxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2356
01920         {(char *)"xzxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2868
01921         {(char *)"xzxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3380
01922         {(char *)"xzxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3892
01923         {(char *)"xzy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 372
01924         {(char *)"xzyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2420
01925         {(char *)"xzyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2932
01926         {(char *)"xzyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3444
01927         {(char *)"xzyw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3956
01928         {(char *)"xzz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 436
01929         {(char *)"xzzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2484
01930         {(char *)"xzzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2996
01931         {(char *)"xzzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3508
01932         {(char *)"xzzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4020
01933         {(char *)"xzw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 500
01934         {(char *)"xzwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2548
01935         {(char *)"xzwy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3060
01936         {(char *)"xzwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3572
01937         {(char *)"xzww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4084
01938         {(char *)"xw",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 60
01939         {(char *)"xwx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 316
01940         {(char *)"xwxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2364
01941         {(char *)"xwxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2876
01942         {(char *)"xwxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3388
01943         {(char *)"xwxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3900
01944         {(char *)"xwy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 380
01945         {(char *)"xwyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2428
01946         {(char *)"xwyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2940
01947         {(char *)"xwyz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3452
01948         {(char *)"xwyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3964
01949         {(char *)"xwz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 444
01950         {(char *)"xwzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2492
01951         {(char *)"xwzy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3004
01952         {(char *)"xwzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3516
01953         {(char *)"xwzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4028
01954         {(char *)"xww",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 508
01955         {(char *)"xwwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2556
01956         {(char *)"xwwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3068
01957         {(char *)"xwwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3580
01958         {(char *)"xwww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4092
01959         {(char *)"yx",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 37
01960         {(char *)"yxx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 293
01961         {(char *)"yxxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2341
01962         {(char *)"yxxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2853
01963         {(char *)"yxxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3365
01964         {(char *)"yxxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3877
01965         {(char *)"yxy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 357
01966         {(char *)"yxyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2405
01967         {(char *)"yxyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2917
01968         {(char *)"yxyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3429
01969         {(char *)"yxyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3941
01970         {(char *)"yxz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 421
01971         {(char *)"yxzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2469
01972         {(char *)"yxzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2981
01973         {(char *)"yxzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3493
01974         {(char *)"yxzw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4005
01975         {(char *)"yxw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 485
01976         {(char *)"yxwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2533
01977         {(char *)"yxwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3045
01978         {(char *)"yxwz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3557
01979         {(char *)"yxww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4069
01980         {(char *)"yy",   (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 45
01981         {(char *)"yyx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 301
01982         {(char *)"yyxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2349
01983         {(char *)"yyxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2861
01984         {(char *)"yyxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3373
01985         {(char *)"yyxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3885
01986         {(char *)"yyy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 365
01987         {(char *)"yyyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2413
01988         {(char *)"yyyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2925
01989         {(char *)"yyyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3437
01990         {(char *)"yyyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3949
01991         {(char *)"yyz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 429
01992         {(char *)"yyzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2477
01993         {(char *)"yyzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2989
01994         {(char *)"yyzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3501
01995         {(char *)"yyzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4013
01996         {(char *)"yyw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 493
01997         {(char *)"yywx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2541
01998         {(char *)"yywy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3053
01999         {(char *)"yywz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3565
02000         {(char *)"yyww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4077
02001         {(char *)"yz",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 53
02002         {(char *)"yzx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 309
02003         {(char *)"yzxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2357
02004         {(char *)"yzxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2869
02005         {(char *)"yzxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3381
02006         {(char *)"yzxw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3893
02007         {(char *)"yzy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 373
02008         {(char *)"yzyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2421
02009         {(char *)"yzyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2933
02010         {(char *)"yzyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3445
02011         {(char *)"yzyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3957
02012         {(char *)"yzz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 437
02013         {(char *)"yzzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2485
02014         {(char *)"yzzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2997
02015         {(char *)"yzzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3509
02016         {(char *)"yzzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4021
02017         {(char *)"yzw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 501
02018         {(char *)"yzwx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2549
02019         {(char *)"yzwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3061
02020         {(char *)"yzwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3573
02021         {(char *)"yzww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4085
02022         {(char *)"yw",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 61
02023         {(char *)"ywx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 317
02024         {(char *)"ywxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2365
02025         {(char *)"ywxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2877
02026         {(char *)"ywxz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3389
02027         {(char *)"ywxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3901
02028         {(char *)"ywy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 381
02029         {(char *)"ywyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2429
02030         {(char *)"ywyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2941
02031         {(char *)"ywyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3453
02032         {(char *)"ywyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3965
02033         {(char *)"ywz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 445
02034         {(char *)"ywzx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2493
02035         {(char *)"ywzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3005
02036         {(char *)"ywzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3517
02037         {(char *)"ywzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4029
02038         {(char *)"yww",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 509
02039         {(char *)"ywwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2557
02040         {(char *)"ywwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3069
02041         {(char *)"ywwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3581
02042         {(char *)"ywww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4093
02043         {(char *)"zx",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 38
02044         {(char *)"zxx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 294
02045         {(char *)"zxxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2342
02046         {(char *)"zxxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2854
02047         {(char *)"zxxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3366
02048         {(char *)"zxxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3878
02049         {(char *)"zxy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 358
02050         {(char *)"zxyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2406
02051         {(char *)"zxyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2918
02052         {(char *)"zxyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3430
02053         {(char *)"zxyw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3942
02054         {(char *)"zxz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 422
02055         {(char *)"zxzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2470
02056         {(char *)"zxzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2982
02057         {(char *)"zxzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3494
02058         {(char *)"zxzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4006
02059         {(char *)"zxw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 486
02060         {(char *)"zxwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2534
02061         {(char *)"zxwy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3046
02062         {(char *)"zxwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3558
02063         {(char *)"zxww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4070
02064         {(char *)"zy",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 46
02065         {(char *)"zyx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 302
02066         {(char *)"zyxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2350
02067         {(char *)"zyxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2862
02068         {(char *)"zyxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3374
02069         {(char *)"zyxw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3886
02070         {(char *)"zyy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 366
02071         {(char *)"zyyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2414
02072         {(char *)"zyyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2926
02073         {(char *)"zyyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3438
02074         {(char *)"zyyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3950
02075         {(char *)"zyz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 430
02076         {(char *)"zyzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2478
02077         {(char *)"zyzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2990
02078         {(char *)"zyzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3502
02079         {(char *)"zyzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4014
02080         {(char *)"zyw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 494
02081         {(char *)"zywx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2542
02082         {(char *)"zywy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3054
02083         {(char *)"zywz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3566
02084         {(char *)"zyww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4078
02085         {(char *)"zz",   (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 54
02086         {(char *)"zzx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 310
02087         {(char *)"zzxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2358
02088         {(char *)"zzxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2870
02089         {(char *)"zzxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3382
02090         {(char *)"zzxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3894
02091         {(char *)"zzy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 374
02092         {(char *)"zzyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2422
02093         {(char *)"zzyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2934
02094         {(char *)"zzyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3446
02095         {(char *)"zzyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3958
02096         {(char *)"zzz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 438
02097         {(char *)"zzzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2486
02098         {(char *)"zzzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2998
02099         {(char *)"zzzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3510
02100         {(char *)"zzzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4022
02101         {(char *)"zzw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 502
02102         {(char *)"zzwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2550
02103         {(char *)"zzwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3062
02104         {(char *)"zzwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3574
02105         {(char *)"zzww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4086
02106         {(char *)"zw",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 62
02107         {(char *)"zwx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 318
02108         {(char *)"zwxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2366
02109         {(char *)"zwxy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2878
02110         {(char *)"zwxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3390
02111         {(char *)"zwxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3902
02112         {(char *)"zwy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 382
02113         {(char *)"zwyx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2430
02114         {(char *)"zwyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2942
02115         {(char *)"zwyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3454
02116         {(char *)"zwyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3966
02117         {(char *)"zwz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 446
02118         {(char *)"zwzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2494
02119         {(char *)"zwzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3006
02120         {(char *)"zwzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3518
02121         {(char *)"zwzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4030
02122         {(char *)"zww",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 510
02123         {(char *)"zwwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2558
02124         {(char *)"zwwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3070
02125         {(char *)"zwwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3582
02126         {(char *)"zwww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4094
02127         {(char *)"wx",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 39
02128         {(char *)"wxx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 295
02129         {(char *)"wxxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2343
02130         {(char *)"wxxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2855
02131         {(char *)"wxxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3367
02132         {(char *)"wxxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3879
02133         {(char *)"wxy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 359
02134         {(char *)"wxyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2407
02135         {(char *)"wxyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2919
02136         {(char *)"wxyz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3431
02137         {(char *)"wxyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3943
02138         {(char *)"wxz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 423
02139         {(char *)"wxzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2471
02140         {(char *)"wxzy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2983
02141         {(char *)"wxzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3495
02142         {(char *)"wxzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4007
02143         {(char *)"wxw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 487
02144         {(char *)"wxwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2535
02145         {(char *)"wxwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3047
02146         {(char *)"wxwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3559
02147         {(char *)"wxww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4071
02148         {(char *)"wy",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 47
02149         {(char *)"wyx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 303
02150         {(char *)"wyxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2351
02151         {(char *)"wyxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2863
02152         {(char *)"wyxz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3375
02153         {(char *)"wyxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3887
02154         {(char *)"wyy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 367
02155         {(char *)"wyyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2415
02156         {(char *)"wyyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2927
02157         {(char *)"wyyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3439
02158         {(char *)"wyyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3951
02159         {(char *)"wyz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 431
02160         {(char *)"wyzx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2479
02161         {(char *)"wyzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2991
02162         {(char *)"wyzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3503
02163         {(char *)"wyzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4015
02164         {(char *)"wyw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 495
02165         {(char *)"wywx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2543
02166         {(char *)"wywy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3055
02167         {(char *)"wywz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3567
02168         {(char *)"wyww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4079
02169         {(char *)"wz",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 55
02170         {(char *)"wzx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 311
02171         {(char *)"wzxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2359
02172         {(char *)"wzxy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2871
02173         {(char *)"wzxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3383
02174         {(char *)"wzxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3895
02175         {(char *)"wzy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 375
02176         {(char *)"wzyx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2423
02177         {(char *)"wzyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2935
02178         {(char *)"wzyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3447
02179         {(char *)"wzyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3959
02180         {(char *)"wzz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 439
02181         {(char *)"wzzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2487
02182         {(char *)"wzzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2999
02183         {(char *)"wzzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3511
02184         {(char *)"wzzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4023
02185         {(char *)"wzw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 503
02186         {(char *)"wzwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2551
02187         {(char *)"wzwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3063
02188         {(char *)"wzwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3575
02189         {(char *)"wzww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4087
02190         {(char *)"ww",   (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 63
02191         {(char *)"wwx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 319
02192         {(char *)"wwxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2367
02193         {(char *)"wwxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2879
02194         {(char *)"wwxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3391
02195         {(char *)"wwxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3903
02196         {(char *)"wwy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 383
02197         {(char *)"wwyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2431
02198         {(char *)"wwyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2943
02199         {(char *)"wwyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3455
02200         {(char *)"wwyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3967
02201         {(char *)"wwz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 447
02202         {(char *)"wwzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2495
02203         {(char *)"wwzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3007
02204         {(char *)"wwzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3519
02205         {(char *)"wwzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4031
02206         {(char *)"www",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 511
02207         {(char *)"wwwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2559
02208         {(char *)"wwwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3071
02209         {(char *)"wwwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3583
02210         {(char *)"wwww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4095
02211         {NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
02212 };
02213 
02214 /* Python script used to make swizzle array */
02215 /*
02216 SWIZZLE_BITS_PER_AXIS = 3
02217 SWIZZLE_VALID_AXIS = 0x4
02218 
02219 axis_dict = {}
02220 axis_pos = {'x':0, 'y':1, 'z':2, 'w':3}
02221 axises = 'xyzw'
02222 while len(axises) >= 2:
02223 
02224         for axis_0 in axises:
02225                 axis_0_pos = axis_pos[axis_0]
02226                 for axis_1 in axises:
02227                         axis_1_pos = axis_pos[axis_1]
02228                         axis_dict[axis_0+axis_1] = '((%s|SWIZZLE_VALID_AXIS) | ((%s|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS))' % (axis_0_pos, axis_1_pos)
02229                         if len(axises)>2:
02230                                 for axis_2 in axises:
02231                                         axis_2_pos = axis_pos[axis_2]
02232                                         axis_dict[axis_0+axis_1+axis_2] = '((%s|SWIZZLE_VALID_AXIS) | ((%s|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((%s|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)))' % (axis_0_pos, axis_1_pos, axis_2_pos)
02233                                         if len(axises)>3:
02234                                                 for axis_3 in axises:
02235                                                         axis_3_pos = axis_pos[axis_3]
02236                                                         axis_dict[axis_0+axis_1+axis_2+axis_3] = '((%s|SWIZZLE_VALID_AXIS) | ((%s|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((%s|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((%s|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  ' % (axis_0_pos, axis_1_pos, axis_2_pos, axis_3_pos)
02237 
02238         axises = axises[:-1]
02239 
02240 
02241 items = axis_dict.items()
02242 items.sort(key = lambda a: a[0].replace('x', '0').replace('y', '1').replace('z', '2').replace('w', '3'))
02243 
02244 unique = set()
02245 for key, val in items:
02246         num = eval(val)
02247         set_str = 'Vector_setSwizzle' if (len(set(key)) == len(key)) else 'NULL'
02248         print '\t{"%s", %s(getter)Vector_getSwizzle, (setter)%s, NULL, SET_INT_IN_POINTER(%s)}, // %s' % (key, (' '*(4-len(key))), set_str, axis_dict[key], num)
02249         unique.add(num)
02250 
02251 if len(unique) != len(items):
02252         print "ERROR"
02253 */
02254 
02255 #if 0
02256 //ROW VECTOR Multiplication - Vector X Matrix
02257 //[x][y][z] *  [1][4][7]
02258 //             [2][5][8]
02259 //             [3][6][9]
02260 //vector/matrix multiplication IS NOT COMMUTATIVE!!!!
02261 static int row_vector_multiplication(float rvec[4], VectorObject* vec, MatrixObject * mat)
02262 {
02263         float vec_cpy[4];
02264         double dot = 0.0f;
02265         int x, y, z = 0, vec_size = vec->size;
02266 
02267         if(mat->colSize != vec_size){
02268                 if(mat->colSize == 4 && vec_size != 3){
02269                         PyErr_SetString(PyExc_ValueError,
02270                                         "vector * matrix: matrix column size "
02271                                         "and the vector size must be the same");
02272                         return -1;
02273                 }
02274                 else {
02275                         vec_cpy[3] = 1.0f;
02276                 }
02277         }
02278 
02279         if(BaseMath_ReadCallback(vec) == -1 || BaseMath_ReadCallback(mat) == -1)
02280                 return -1;
02281 
02282         memcpy(vec_cpy, vec->vec, vec_size * sizeof(float));
02283 
02284         rvec[3] = 1.0f;
02285         //muliplication
02286         for(x = 0; x < mat->rowSize; x++) {
02287                 for(y = 0; y < mat->colSize; y++) {
02288                         dot += mat->matrix[x][y] * vec_cpy[y];
02289                 }
02290                 rvec[z++] = (float)dot;
02291                 dot = 0.0f;
02292         }
02293         return 0;
02294 }
02295 #endif
02296 
02297 /*----------------------------Vector.negate() -------------------- */
02298 PyDoc_STRVAR(Vector_negate_doc,
02299 ".. method:: negate()\n"
02300 "\n"
02301 "   Set all values to their negative.\n"
02302 "\n"
02303 "   :return: an instance of itself\n"
02304 "   :rtype: :class:`Vector`\n"
02305 );
02306 static PyObject *Vector_negate(VectorObject *self)
02307 {
02308         if(BaseMath_ReadCallback(self) == -1)
02309                 return NULL;
02310 
02311         negate_vn(self->vec, self->size);
02312 
02313         (void)BaseMath_WriteCallback(self); // already checked for error
02314         Py_RETURN_NONE;
02315 }
02316 
02317 static struct PyMethodDef Vector_methods[] = {
02318         /* in place only */
02319         {"zero", (PyCFunction) Vector_zero, METH_NOARGS, Vector_zero_doc},
02320         {"negate", (PyCFunction) Vector_negate, METH_NOARGS, Vector_negate_doc},
02321 
02322         /* operate on original or copy */
02323         {"normalize", (PyCFunction) Vector_normalize, METH_NOARGS, Vector_normalize_doc},
02324         {"normalized", (PyCFunction) Vector_normalized, METH_NOARGS, Vector_normalized_doc},
02325 
02326         {"to_2d", (PyCFunction) Vector_to_2d, METH_NOARGS, Vector_to_2d_doc},
02327         {"resize_2d", (PyCFunction) Vector_resize_2d, METH_NOARGS, Vector_resize_2d_doc},
02328         {"to_3d", (PyCFunction) Vector_to_3d, METH_NOARGS, Vector_to_3d_doc},
02329         {"resize_3d", (PyCFunction) Vector_resize_3d, METH_NOARGS, Vector_resize_3d_doc},
02330         {"to_4d", (PyCFunction) Vector_to_4d, METH_NOARGS, Vector_to_4d_doc},
02331         {"resize_4d", (PyCFunction) Vector_resize_4d, METH_NOARGS, Vector_resize_4d_doc},
02332         {"to_tuple", (PyCFunction) Vector_to_tuple, METH_VARARGS, Vector_to_tuple_doc},
02333         {"to_track_quat", (PyCFunction) Vector_to_track_quat, METH_VARARGS, Vector_to_track_quat_doc},
02334 
02335         /* operation between 2 or more types  */
02336         {"reflect", (PyCFunction) Vector_reflect, METH_O, Vector_reflect_doc},
02337         {"cross", (PyCFunction) Vector_cross, METH_O, Vector_cross_doc},
02338         {"dot", (PyCFunction) Vector_dot, METH_O, Vector_dot_doc},
02339         {"angle", (PyCFunction) Vector_angle, METH_VARARGS, Vector_angle_doc},
02340         {"rotation_difference", (PyCFunction) Vector_rotation_difference, METH_O, Vector_rotation_difference_doc},
02341         {"project", (PyCFunction) Vector_project, METH_O, Vector_project_doc},
02342         {"lerp", (PyCFunction) Vector_lerp, METH_VARARGS, Vector_lerp_doc},
02343         {"rotate", (PyCFunction) Vector_rotate, METH_O, Vector_rotate_doc},
02344 
02345         {"copy", (PyCFunction) Vector_copy, METH_NOARGS, Vector_copy_doc},
02346         {"__copy__", (PyCFunction) Vector_copy, METH_NOARGS, NULL},
02347         {NULL, NULL, 0, NULL}
02348 };
02349 
02350 
02351 /* Note
02352  Py_TPFLAGS_CHECKTYPES allows us to avoid casting all types to Vector when coercing
02353  but this means for eg that
02354  vec*mat and mat*vec both get sent to Vector_mul and it neesd to sort out the order
02355 */
02356 
02357 PyDoc_STRVAR(vector_doc,
02358 "This object gives access to Vectors in Blender."
02359 );
02360 PyTypeObject vector_Type = {
02361         PyVarObject_HEAD_INIT(NULL, 0)
02362         /*  For printing, in format "<module>.<name>" */
02363         "mathutils.Vector",             /* char *tp_name; */
02364         sizeof(VectorObject),         /* int tp_basicsize; */
02365         0,                          /* tp_itemsize;  For allocation */
02366 
02367         /* Methods to implement standard operations */
02368 
02369         (destructor) BaseMathObject_dealloc,/* destructor tp_dealloc; */
02370         NULL,                       /* printfunc tp_print; */
02371         NULL,                       /* getattrfunc tp_getattr; */
02372         NULL,                       /* setattrfunc tp_setattr; */
02373         NULL,   /* cmpfunc tp_compare; */
02374         (reprfunc)Vector_repr,     /* reprfunc tp_repr; */
02375 
02376         /* Method suites for standard classes */
02377 
02378         &Vector_NumMethods,                       /* PyNumberMethods *tp_as_number; */
02379         &Vector_SeqMethods,                       /* PySequenceMethods *tp_as_sequence; */
02380         &Vector_AsMapping,                       /* PyMappingMethods *tp_as_mapping; */
02381 
02382         /* More standard operations (here for binary compatibility) */
02383 
02384         NULL,                       /* hashfunc tp_hash; */
02385         NULL,                       /* ternaryfunc tp_call; */
02386         NULL,                       /* reprfunc tp_str; */
02387         NULL,                       /* getattrofunc tp_getattro; */
02388         NULL,                       /* setattrofunc tp_setattro; */
02389 
02390         /* Functions to access object as input/output buffer */
02391         NULL,                       /* PyBufferProcs *tp_as_buffer; */
02392 
02393   /*** Flags to define presence of optional/expanded features ***/
02394         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
02395         vector_doc,                       /*  char *tp_doc;  Documentation string */
02396   /*** Assigned meaning in release 2.0 ***/
02397 
02398         /* call function for all accessible objects */
02399         (traverseproc)BaseMathObject_traverse,  //tp_traverse
02400 
02401         /* delete references to contained objects */
02402         (inquiry)BaseMathObject_clear,  //tp_clear
02403 
02404   /***  Assigned meaning in release 2.1 ***/
02405   /*** rich comparisons ***/
02406         (richcmpfunc)Vector_richcmpr,                       /* richcmpfunc tp_richcompare; */
02407 
02408   /***  weak reference enabler ***/
02409         0,                          /* long tp_weaklistoffset; */
02410 
02411   /*** Added in release 2.2 ***/
02412         /*   Iterators */
02413         NULL,                       /* getiterfunc tp_iter; */
02414         NULL,                       /* iternextfunc tp_iternext; */
02415 
02416   /*** Attribute descriptor and subclassing stuff ***/
02417         Vector_methods,           /* struct PyMethodDef *tp_methods; */
02418         NULL,                       /* struct PyMemberDef *tp_members; */
02419         Vector_getseters,           /* struct PyGetSetDef *tp_getset; */
02420         NULL,                       /* struct _typeobject *tp_base; */
02421         NULL,                       /* PyObject *tp_dict; */
02422         NULL,                       /* descrgetfunc tp_descr_get; */
02423         NULL,                       /* descrsetfunc tp_descr_set; */
02424         0,                          /* long tp_dictoffset; */
02425         NULL,                       /* initproc tp_init; */
02426         NULL,                       /* allocfunc tp_alloc; */
02427         Vector_new,                 /* newfunc tp_new; */
02428         /*  Low-level free-memory routine */
02429         NULL,                       /* freefunc tp_free;  */
02430         /* For PyObject_IS_GC */
02431         NULL,                       /* inquiry tp_is_gc;  */
02432         NULL,                       /* PyObject *tp_bases; */
02433         /* method resolution order */
02434         NULL,                       /* PyObject *tp_mro;  */
02435         NULL,                       /* PyObject *tp_cache; */
02436         NULL,                       /* PyObject *tp_subclasses; */
02437         NULL,                       /* PyObject *tp_weaklist; */
02438         NULL
02439 };
02440 
02441 /*------------------------newVectorObject (internal)-------------
02442   creates a new vector object
02443   pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
02444  (i.e. it was allocated elsewhere by MEM_mallocN())
02445   pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
02446  (i.e. it must be created here with PyMEM_malloc())*/
02447 PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObject *base_type)
02448 {
02449         VectorObject *self;
02450 
02451         if(size > 4 || size < 2) {
02452                 PyErr_SetString(PyExc_RuntimeError,
02453                                 "Vector(): invalid size");
02454                 return NULL;
02455         }
02456 
02457         self= base_type ?       (VectorObject *)base_type->tp_alloc(base_type, 0) :
02458                                                 (VectorObject *)PyObject_GC_New(VectorObject, &vector_Type);
02459 
02460         if(self) {
02461                 self->size = size;
02462 
02463                 /* init callbacks as NULL */
02464                 self->cb_user= NULL;
02465                 self->cb_type= self->cb_subtype= 0;
02466 
02467                 if(type == Py_WRAP) {
02468                         self->vec = vec;
02469                         self->wrapped = Py_WRAP;
02470                 }
02471                 else if (type == Py_NEW) {
02472                         self->vec= PyMem_Malloc(size * sizeof(float));
02473                         if(vec) {
02474                                 memcpy(self->vec, vec, size * sizeof(float));
02475                         }
02476                         else { /* new empty */
02477                                 fill_vn(self->vec, size, 0.0f);
02478                                 if(size == 4) { /* do the homogenous thing */
02479                                         self->vec[3] = 1.0f;
02480                                 }
02481                         }
02482                         self->wrapped = Py_NEW;
02483                 }
02484                 else {
02485                         Py_FatalError("Vector(): invalid type!");
02486                 }
02487         }
02488         return (PyObject *) self;
02489 }
02490 
02491 PyObject *newVectorObject_cb(PyObject *cb_user, int size, int cb_type, int cb_subtype)
02492 {
02493         float dummy[4] = {0.0, 0.0, 0.0, 0.0}; /* dummy init vector, callbacks will be used on access */
02494         VectorObject *self= (VectorObject *)newVectorObject(dummy, size, Py_NEW, NULL);
02495         if(self) {
02496                 Py_INCREF(cb_user);
02497                 self->cb_user=                  cb_user;
02498                 self->cb_type=                  (unsigned char)cb_type;
02499                 self->cb_subtype=               (unsigned char)cb_subtype;
02500                 PyObject_GC_Track(self);
02501         }
02502 
02503         return (PyObject *)self;
02504 }