style cleanup: python api
[blender.git] / source / blender / python / mathutils / mathutils_Vector.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  *
22  * Contributor(s): Willian P. Germano, Joseph Gilbert, Ken Hughes, Alex Fraser, Campbell Barton
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/python/mathutils/mathutils_Vector.c
28  *  \ingroup pymathutils
29  */
30
31
32 #include <Python.h>
33
34 #include "mathutils.h"
35
36 #include "BLI_math.h"
37 #include "BLI_utildefines.h"
38 #include "BLI_dynstr.h"
39
40 #define MAX_DIMENSIONS 4
41
42 /* Swizzle axes get packed into a single value that is used as a closure. Each
43  * axis uses SWIZZLE_BITS_PER_AXIS bits. The first bit (SWIZZLE_VALID_AXIS) is
44  * used as a sentinel: if it is unset, the axis is not valid. */
45 #define SWIZZLE_BITS_PER_AXIS 3
46 #define SWIZZLE_VALID_AXIS 0x4
47 #define SWIZZLE_AXIS       0x3
48
49 static PyObject *Vector_copy(VectorObject *self);
50 static PyObject *Vector_to_tuple_ext(VectorObject *self, int ndigits);
51 static int row_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject *vec, MatrixObject *mat);
52
53 /* Supports 2D, 3D, and 4D vector objects both int and float values
54  * accepted. Mixed float and int values accepted. Ints are parsed to float
55  */
56 static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED(kwds))
57 {
58         float *vec = NULL;
59         int size = 3; /* default to a 3D vector */
60
61         switch (PyTuple_GET_SIZE(args)) {
62                 case 0:
63                         vec = PyMem_Malloc(size * sizeof(float));
64
65                         if (vec == NULL) {
66                                 PyErr_SetString(PyExc_MemoryError,
67                                                 "Vector(): "
68                                                 "problem allocating pointer space");
69                                 return NULL;
70                         }
71
72                         fill_vn_fl(vec, size, 0.0f);
73                         break;
74                 case 1:
75                         if ((size = mathutils_array_parse_alloc(&vec, 2, PyTuple_GET_ITEM(args, 0), "mathutils.Vector()")) == -1) {
76                                 if (vec) {
77                                         PyMem_Free(vec);
78                                 }
79                                 return NULL;
80                         }
81                         break;
82                 default:
83                         PyErr_SetString(PyExc_TypeError,
84                                         "mathutils.Vector(): "
85                                         "more then a single arg given");
86                         return NULL;
87         }
88         return Vector_CreatePyObject(vec, size, Py_NEW, type);
89 }
90
91 static PyObject *vec__apply_to_copy(PyNoArgsFunction vec_func, VectorObject *self)
92 {
93         PyObject *ret = Vector_copy(self);
94         PyObject *ret_dummy = vec_func(ret);
95         if (ret_dummy) {
96                 Py_DECREF(ret_dummy);
97                 return (PyObject *)ret;
98         }
99         else { /* error */
100                 Py_DECREF(ret);
101                 return NULL;
102         }
103 }
104
105 /*-----------------------CLASS-METHODS----------------------------*/
106 PyDoc_STRVAR(C_Vector_Fill_doc,
107 ".. classmethod:: Fill(size, fill=0.0)\n"
108 "\n"
109 "   Create a vector of length size with all values set to fill.\n"
110 "\n"
111 "   :arg size: The length of the vector to be created.\n"
112 "   :type size: int\n"
113 "   :arg fill: The value used to fill the vector.\n"
114 "   :type fill: float\n"
115 );
116 static PyObject *C_Vector_Fill(PyObject *cls, PyObject *args)
117 {
118         float *vec;
119         int size;
120         float fill = 0.0f;
121
122         if (!PyArg_ParseTuple(args, "i|f:Vector.Fill", &size, &fill)) {
123                 return NULL;
124         }
125
126         if (size < 2) {
127                 PyErr_SetString(PyExc_RuntimeError,
128                                 "Vector(): invalid size");
129                 return NULL;
130         }
131
132         vec = PyMem_Malloc(size * sizeof(float));
133
134         if (vec == NULL) {
135                 PyErr_SetString(PyExc_MemoryError,
136                                 "Vector.Fill(): "
137                                 "problem allocating pointer space");
138                 return NULL;
139         }
140
141         fill_vn_fl(vec, size, fill);
142
143         return Vector_CreatePyObject_alloc(vec, size, (PyTypeObject *)cls);
144 }
145
146 PyDoc_STRVAR(C_Vector_Range_doc,
147 ".. classmethod:: Range(start=0, stop, step=1)\n"
148 "\n"
149 "   Create a filled with a range of values.\n"
150 "\n"
151 "   :arg start: The start of the range used to fill the vector.\n"
152 "   :type start: int\n"
153 "   :arg stop: The end of the range used to fill the vector.\n"
154 "   :type stop: int\n"
155 "   :arg step: The step between successive values in the vector.\n"
156 "   :type step: int\n"
157 );
158 static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
159 {
160         float *vec;
161         int stop, size;
162         int start = 0;
163         int step = 1;
164
165         if (!PyArg_ParseTuple(args, "i|ii:Vector.Range", &start, &stop, &step)) {
166                 return NULL;
167         }
168
169         switch (PyTuple_GET_SIZE(args)) {
170                 case 1:
171                         size = start;
172                         start = 0;
173                         break;
174                 case 2:
175                         if (start >= stop) {
176                                 PyErr_SetString(PyExc_RuntimeError,
177                                                 "Start value is larger "
178                                                 "than the stop value");
179                                 return NULL;
180                         }
181
182                         size = stop - start;
183                         break;
184                 default:
185                         if (start >= stop) {
186                                 PyErr_SetString(PyExc_RuntimeError,
187                                                 "Start value is larger "
188                                                 "than the stop value");
189                                 return NULL;
190                         }
191
192                         size = (stop - start);
193
194                         if ((size % step) != 0)
195                                 size += step;
196
197                         size /= step;
198
199                         break;
200         }
201
202         if (size < 2) {
203                 PyErr_SetString(PyExc_RuntimeError,
204                                 "Vector(): invalid size");
205                 return NULL;
206         }
207
208         vec = PyMem_Malloc(size * sizeof(float));
209
210         if (vec == NULL) {
211                 PyErr_SetString(PyExc_MemoryError,
212                                 "Vector.Range(): "
213                                 "problem allocating pointer space");
214                 return NULL;
215         }
216
217         range_vn_fl(vec, size, (float)start, (float)step);
218
219         return Vector_CreatePyObject_alloc(vec, size, (PyTypeObject *)cls);
220 }
221
222 PyDoc_STRVAR(C_Vector_Linspace_doc,
223 ".. classmethod:: Linspace(start, stop, size)\n"
224 "\n"
225 "   Create a vector of the specified size which is filled with linearly spaced values between start and stop values.\n"
226 "\n"
227 "   :arg start: The start of the range used to fill the vector.\n"
228 "   :type start: int\n"
229 "   :arg stop: The end of the range used to fill the vector.\n"
230 "   :type stop: int\n"
231 "   :arg size: The size of the vector to be created.\n"
232 "   :type size: int\n"
233 );
234 static PyObject *C_Vector_Linspace(PyObject *cls, PyObject *args)
235 {
236         float *vec;
237         int size;
238         float start, end, step;
239
240         if (!PyArg_ParseTuple(args, "ffi:Vector.Linspace", &start, &end, &size)) {
241                 return NULL;
242         }
243
244         if (size < 2) {
245                 PyErr_SetString(PyExc_RuntimeError,
246                                 "Vector.Linspace(): invalid size");
247                 return NULL;
248         }
249
250         step = (end - start) / (float)(size - 1);
251
252         vec = PyMem_Malloc(size * sizeof(float));
253
254         if (vec == NULL) {
255                 PyErr_SetString(PyExc_MemoryError,
256                                 "Vector.Linspace(): "
257                                 "problem allocating pointer space");
258                 return NULL;
259         }
260
261         range_vn_fl(vec, size, start, step);
262
263         return Vector_CreatePyObject_alloc(vec, size, (PyTypeObject *)cls);
264 }
265
266 PyDoc_STRVAR(C_Vector_Repeat_doc,
267 ".. classmethod:: Repeat(vector, size)\n"
268 "\n"
269 "   Create a vector by repeating the values in vector until the required size is reached.\n"
270 "\n"
271 "   :arg tuple: The vector to draw values from.\n"
272 "   :type tuple: :class:`mathutils.Vector`\n"
273 "   :arg size: The size of the vector to be created.\n"
274 "   :type size: int\n"
275 );
276 static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args)
277 {
278         float *vec;
279         float *iter_vec = NULL;
280         int i, size, value_size;
281         PyObject *value;
282
283         if (!PyArg_ParseTuple(args, "Oi:Vector.Repeat", &value, &size)) {
284                 return NULL;
285         }
286
287         if (size < 2) {
288                 PyErr_SetString(PyExc_RuntimeError,
289                                 "Vector.Repeat(): invalid size");
290                 return NULL;
291         }
292
293         if ((value_size = mathutils_array_parse_alloc(&iter_vec, 2, value,
294                                                       "Vector.Repeat(vector, size), invalid 'vector' arg")) == -1)
295         {
296                 PyMem_Free(iter_vec);
297                 return NULL;
298         }
299
300         if (iter_vec == NULL) {
301                 PyErr_SetString(PyExc_MemoryError,
302                                 "Vector.Repeat(): "
303                                 "problem allocating pointer space");
304                 return NULL;
305         }
306
307         vec = PyMem_Malloc(size * sizeof(float));
308
309         if (vec == NULL) {
310                 PyErr_SetString(PyExc_MemoryError,
311                                 "Vector.Repeat(): "
312                                 "problem allocating pointer space");
313                 return NULL;
314         }
315
316         i = 0;
317         while (i < size) {
318                 vec[i] = iter_vec[i % value_size];
319                 i++;
320         }
321
322         PyMem_Free(iter_vec);
323
324         return Vector_CreatePyObject_alloc(vec, size, (PyTypeObject *)cls);
325 }
326
327 /*-----------------------------METHODS---------------------------- */
328 PyDoc_STRVAR(Vector_zero_doc,
329 ".. method:: zero()\n"
330 "\n"
331 "   Set all values to zero.\n"
332 );
333 static PyObject *Vector_zero(VectorObject *self)
334 {
335         fill_vn_fl(self->vec, self->size, 0.0f);
336
337         if (BaseMath_WriteCallback(self) == -1)
338                 return NULL;
339
340         Py_RETURN_NONE;
341 }
342
343 PyDoc_STRVAR(Vector_normalize_doc,
344 ".. method:: normalize()\n"
345 "\n"
346 "   Normalize the vector, making the length of the vector always 1.0.\n"
347 "\n"
348 "   .. warning:: Normalizing a vector where all values are zero has no effect.\n"
349 "\n"
350 "   .. note:: Normalize works for vectors of all sizes,\n"
351 "      however 4D Vectors w axis is left untouched.\n"
352 );
353 static PyObject *Vector_normalize(VectorObject *self)
354 {
355         int size = (self->size == 4 ? 3 : self->size);
356         if (BaseMath_ReadCallback(self) == -1)
357                 return NULL;
358
359         normalize_vn(self->vec, size);
360
361         (void)BaseMath_WriteCallback(self);
362         Py_RETURN_NONE;
363 }
364 PyDoc_STRVAR(Vector_normalized_doc,
365 ".. method:: normalized()\n"
366 "\n"
367 "   Return a new, normalized vector.\n"
368 "\n"
369 "   :return: a normalized copy of the vector\n"
370 "   :rtype: :class:`Vector`\n"
371 );
372 static PyObject *Vector_normalized(VectorObject *self)
373 {
374         return vec__apply_to_copy((PyNoArgsFunction)Vector_normalize, self);
375 }
376
377 PyDoc_STRVAR(Vector_resize_doc,
378 ".. method:: resize(size=3)\n"
379 "\n"
380 "   Resize the vector to have size number of elements.\n"
381 );
382 static PyObject *Vector_resize(VectorObject *self, PyObject *value)
383 {
384         int size;
385
386         if (self->wrapped == Py_WRAP) {
387                 PyErr_SetString(PyExc_TypeError,
388                                 "Vector.resize(): "
389                                 "cannot resize wrapped data - only python vectors");
390                 return NULL;
391         }
392         if (self->cb_user) {
393                 PyErr_SetString(PyExc_TypeError,
394                                 "Vector.resize(): "
395                                 "cannot resize a vector that has an owner");
396                 return NULL;
397         }
398
399         if ((size = PyLong_AsLong(value)) == -1) {
400                 PyErr_SetString(PyExc_TypeError,
401                                 "Vector.resize(size): "
402                                 "expected size argument to be an integer");
403                 return NULL;
404         }
405
406         if (size < 2) {
407                 PyErr_SetString(PyExc_RuntimeError,
408                                 "Vector.resize(): invalid size");
409                 return NULL;
410         }
411
412         self->vec = PyMem_Realloc(self->vec, (size * sizeof(float)));
413         if (self->vec == NULL) {
414                 PyErr_SetString(PyExc_MemoryError,
415                                 "Vector.resize(): "
416                                 "problem allocating pointer space");
417                 return NULL;
418         }
419
420         /* If the vector has increased in length, set all new elements to 0.0f */
421         if (size > self->size) {
422                 fill_vn_fl(self->vec + self->size, size - self->size, 0.0f);
423         }
424
425         self->size = size;
426         Py_RETURN_NONE;
427 }
428
429 PyDoc_STRVAR(Vector_resized_doc,
430 ".. method:: resized(size=3)\n"
431 "\n"
432 "   Return a resized copy of the vector with size number of elements.\n"
433 "\n"
434 "   :return: a new vector\n"
435 "   :rtype: :class:`Vector`\n"
436 );
437 static PyObject *Vector_resized(VectorObject *self, PyObject *value)
438 {
439         int size;
440         float *vec;
441
442         if ((size = PyLong_AsLong(value)) == -1) {
443                 return NULL;
444         }
445
446         if (size < 2) {
447                 PyErr_SetString(PyExc_RuntimeError,
448                                 "Vector.resized(): invalid size");
449                 return NULL;
450         }
451
452         vec = PyMem_Malloc(size * sizeof(float));
453
454         if (vec == NULL) {
455                 PyErr_SetString(PyExc_MemoryError,
456                                 "Vector.resized(): "
457                                 "problem allocating pointer space");
458                 return NULL;
459         }
460
461         fill_vn_fl(vec, size, 0.0f);
462         memcpy(vec, self->vec, self->size * sizeof(float));
463
464         return Vector_CreatePyObject_alloc(vec, size, NULL);
465 }
466
467 PyDoc_STRVAR(Vector_resize_2d_doc,
468 ".. method:: resize_2d()\n"
469 "\n"
470 "   Resize the vector to 2D  (x, y).\n"
471 );
472 static PyObject *Vector_resize_2d(VectorObject *self)
473 {
474         if (self->wrapped == Py_WRAP) {
475                 PyErr_SetString(PyExc_TypeError,
476                                 "Vector.resize_2d(): "
477                                 "cannot resize wrapped data - only python vectors");
478                 return NULL;
479         }
480         if (self->cb_user) {
481                 PyErr_SetString(PyExc_TypeError,
482                                 "Vector.resize_2d(): "
483                                 "cannot resize a vector that has an owner");
484                 return NULL;
485         }
486
487         self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 2));
488         if (self->vec == NULL) {
489                 PyErr_SetString(PyExc_MemoryError,
490                                 "Vector.resize_2d(): "
491                                 "problem allocating pointer space");
492                 return NULL;
493         }
494
495         self->size = 2;
496         Py_RETURN_NONE;
497 }
498
499 PyDoc_STRVAR(Vector_resize_3d_doc,
500 ".. method:: resize_3d()\n"
501 "\n"
502 "   Resize the vector to 3D  (x, y, z).\n"
503 );
504 static PyObject *Vector_resize_3d(VectorObject *self)
505 {
506         if (self->wrapped == Py_WRAP) {
507                 PyErr_SetString(PyExc_TypeError,
508                                 "Vector.resize_3d(): "
509                                 "cannot resize wrapped data - only python vectors");
510                 return NULL;
511         }
512         if (self->cb_user) {
513                 PyErr_SetString(PyExc_TypeError,
514                                 "Vector.resize_3d(): "
515                                 "cannot resize a vector that has an owner");
516                 return NULL;
517         }
518
519         self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 3));
520         if (self->vec == NULL) {
521                 PyErr_SetString(PyExc_MemoryError,
522                                 "Vector.resize_3d(): "
523                                 "problem allocating pointer space");
524                 return NULL;
525         }
526
527         if (self->size == 2)
528                 self->vec[2] = 0.0f;
529
530         self->size = 3;
531         Py_RETURN_NONE;
532 }
533
534 PyDoc_STRVAR(Vector_resize_4d_doc,
535 ".. method:: resize_4d()\n"
536 "\n"
537 "   Resize the vector to 4D (x, y, z, w).\n"
538 );
539 static PyObject *Vector_resize_4d(VectorObject *self)
540 {
541         if (self->wrapped == Py_WRAP) {
542                 PyErr_SetString(PyExc_TypeError,
543                                 "Vector.resize_4d(): "
544                                 "cannot resize wrapped data - only python vectors");
545                 return NULL;
546         }
547         if (self->cb_user) {
548                 PyErr_SetString(PyExc_TypeError,
549                                 "Vector.resize_4d(): "
550                                 "cannot resize a vector that has an owner");
551                 return NULL;
552         }
553
554         self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 4));
555         if (self->vec == NULL) {
556                 PyErr_SetString(PyExc_MemoryError,
557                                 "Vector.resize_4d(): "
558                                 "problem allocating pointer space");
559                 return NULL;
560         }
561
562         if (self->size == 2) {
563                 self->vec[2] = 0.0f;
564                 self->vec[3] = 1.0f;
565         }
566         else if (self->size == 3) {
567                 self->vec[3] = 1.0f;
568         }
569         self->size = 4;
570         Py_RETURN_NONE;
571 }
572 PyDoc_STRVAR(Vector_to_2d_doc,
573 ".. method:: to_2d()\n"
574 "\n"
575 "   Return a 2d copy of the vector.\n"
576 "\n"
577 "   :return: a new vector\n"
578 "   :rtype: :class:`Vector`\n"
579 );
580 static PyObject *Vector_to_2d(VectorObject *self)
581 {
582         if (BaseMath_ReadCallback(self) == -1)
583                 return NULL;
584
585         return Vector_CreatePyObject(self->vec, 2, Py_NEW, Py_TYPE(self));
586 }
587 PyDoc_STRVAR(Vector_to_3d_doc,
588 ".. method:: to_3d()\n"
589 "\n"
590 "   Return a 3d copy of the vector.\n"
591 "\n"
592 "   :return: a new vector\n"
593 "   :rtype: :class:`Vector`\n"
594 );
595 static PyObject *Vector_to_3d(VectorObject *self)
596 {
597         float tvec[3] = {0.0f};
598
599         if (BaseMath_ReadCallback(self) == -1)
600                 return NULL;
601
602         memcpy(tvec, self->vec, sizeof(float) * MIN2(self->size, 3));
603         return Vector_CreatePyObject(tvec, 3, Py_NEW, Py_TYPE(self));
604 }
605 PyDoc_STRVAR(Vector_to_4d_doc,
606 ".. method:: to_4d()\n"
607 "\n"
608 "   Return a 4d copy of the vector.\n"
609 "\n"
610 "   :return: a new vector\n"
611 "   :rtype: :class:`Vector`\n"
612 );
613 static PyObject *Vector_to_4d(VectorObject *self)
614 {
615         float tvec[4] = {0.0f, 0.0f, 0.0f, 1.0f};
616
617         if (BaseMath_ReadCallback(self) == -1)
618                 return NULL;
619
620         memcpy(tvec, self->vec, sizeof(float) * MIN2(self->size, 4));
621         return Vector_CreatePyObject(tvec, 4, Py_NEW, Py_TYPE(self));
622 }
623
624 PyDoc_STRVAR(Vector_to_tuple_doc,
625 ".. method:: to_tuple(precision=-1)\n"
626 "\n"
627 "   Return this vector as a tuple with.\n"
628 "\n"
629 "   :arg precision: The number to round the value to in [-1, 21].\n"
630 "   :type precision: int\n"
631 "   :return: the values of the vector rounded by *precision*\n"
632 "   :rtype: tuple\n"
633 );
634 /* note: BaseMath_ReadCallback must be called beforehand */
635 static PyObject *Vector_to_tuple_ext(VectorObject *self, int ndigits)
636 {
637         PyObject *ret;
638         int i;
639
640         ret = PyTuple_New(self->size);
641
642         if (ndigits >= 0) {
643                 for (i = 0; i < self->size; i++) {
644                         PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->vec[i], ndigits)));
645                 }
646         }
647         else {
648                 for (i = 0; i < self->size; i++) {
649                         PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->vec[i]));
650                 }
651         }
652
653         return ret;
654 }
655
656 static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args)
657 {
658         int ndigits = 0;
659
660         if (!PyArg_ParseTuple(args, "|i:to_tuple", &ndigits))
661                 return NULL;
662
663         if (ndigits > 22 || ndigits < 0) {
664                 PyErr_SetString(PyExc_ValueError,
665                                 "Vector.to_tuple(ndigits): "
666                                 "ndigits must be between 0 and 21");
667                 return NULL;
668         }
669
670         if (PyTuple_GET_SIZE(args) == 0)
671                 ndigits = -1;
672
673         if (BaseMath_ReadCallback(self) == -1)
674                 return NULL;
675
676         return Vector_to_tuple_ext(self, ndigits);
677 }
678
679 PyDoc_STRVAR(Vector_to_track_quat_doc,
680 ".. method:: to_track_quat(track, up)\n"
681 "\n"
682 "   Return a quaternion rotation from the vector and the track and up axis.\n"
683 "\n"
684 "   :arg track: Track axis in ['X', 'Y', 'Z', '-X', '-Y', '-Z'].\n"
685 "   :type track: string\n"
686 "   :arg up: Up axis in ['X', 'Y', 'Z'].\n"
687 "   :type up: string\n"
688 "   :return: rotation from the vector and the track and up axis.\n"
689 "   :rtype: :class:`Quaternion`\n"
690 );
691 static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
692 {
693         float vec[3], quat[4];
694         const char *strack, *sup;
695         short track = 2, up = 1;
696
697         if (!PyArg_ParseTuple(args, "|ss:to_track_quat", &strack, &sup))
698                 return NULL;
699
700         if (self->size != 3) {
701                 PyErr_SetString(PyExc_TypeError,
702                                 "Vector.to_track_quat(): "
703                                 "only for 3D vectors");
704                 return NULL;
705         }
706
707         if (BaseMath_ReadCallback(self) == -1)
708                 return NULL;
709
710         if (strack) {
711                 const char *axis_err_msg = "only X, -X, Y, -Y, Z or -Z for track axis";
712
713                 if (strlen(strack) == 2) {
714                         if (strack[0] == '-') {
715                                 switch (strack[1]) {
716                                         case 'X':
717                                                 track = 3;
718                                                 break;
719                                         case 'Y':
720                                                 track = 4;
721                                                 break;
722                                         case 'Z':
723                                                 track = 5;
724                                                 break;
725                                         default:
726                                                 PyErr_SetString(PyExc_ValueError, axis_err_msg);
727                                                 return NULL;
728                                 }
729                         }
730                         else {
731                                 PyErr_SetString(PyExc_ValueError, axis_err_msg);
732                                 return NULL;
733                         }
734                 }
735                 else if (strlen(strack) == 1) {
736                         switch (strack[0]) {
737                                 case '-':
738                                 case 'X':
739                                         track = 0;
740                                         break;
741                                 case 'Y':
742                                         track = 1;
743                                         break;
744                                 case 'Z':
745                                         track = 2;
746                                         break;
747                                 default:
748                                         PyErr_SetString(PyExc_ValueError, axis_err_msg);
749                                         return NULL;
750                         }
751                 }
752                 else {
753                         PyErr_SetString(PyExc_ValueError, axis_err_msg);
754                         return NULL;
755                 }
756         }
757
758         if (sup) {
759                 const char *axis_err_msg = "only X, Y or Z for up axis";
760                 if (strlen(sup) == 1) {
761                         switch (*sup) {
762                                 case 'X':
763                                         up = 0;
764                                         break;
765                                 case 'Y':
766                                         up = 1;
767                                         break;
768                                 case 'Z':
769                                         up = 2;
770                                         break;
771                                 default:
772                                         PyErr_SetString(PyExc_ValueError, axis_err_msg);
773                                         return NULL;
774                         }
775                 }
776                 else {
777                         PyErr_SetString(PyExc_ValueError, axis_err_msg);
778                         return NULL;
779                 }
780         }
781
782         if (track == up) {
783                 PyErr_SetString(PyExc_ValueError,
784                                 "Can't have the same axis for track and up");
785                 return NULL;
786         }
787
788         /*
789          * flip vector around, since vectoquat expect a vector from target to tracking object
790          * and the python function expects the inverse (a vector to the target).
791          */
792         negate_v3_v3(vec, self->vec);
793
794         vec_to_quat(quat, vec, track, up);
795
796         return Quaternion_CreatePyObject(quat, Py_NEW, NULL);
797 }
798
799 /*
800  * Vector.reflect(mirror): return a reflected vector on the mirror normal
801  *  vec - ((2 * DotVecs(vec, mirror)) * mirror)
802  */
803 PyDoc_STRVAR(Vector_reflect_doc,
804 ".. method:: reflect(mirror)\n"
805 "\n"
806 "   Return the reflection vector from the *mirror* argument.\n"
807 "\n"
808 "   :arg mirror: This vector could be a normal from the reflecting surface.\n"
809 "   :type mirror: :class:`Vector`\n"
810 "   :return: The reflected vector matching the size of this vector.\n"
811 "   :rtype: :class:`Vector`\n"
812 );
813 static PyObject *Vector_reflect(VectorObject *self, PyObject *value)
814 {
815         int value_size;
816         float mirror[3], vec[3];
817         float reflect[3] = {0.0f};
818         float tvec[MAX_DIMENSIONS];
819
820         if (BaseMath_ReadCallback(self) == -1)
821                 return NULL;
822
823         if ((value_size = mathutils_array_parse(tvec, 2, 4, value, "Vector.reflect(other), invalid 'other' arg")) == -1)
824                 return NULL;
825
826         if (self->size < 2 || self->size > 4) {
827                 PyErr_SetString(PyExc_ValueError,
828                                 "Vector must be 2D, 3D or 4D");
829                 return NULL;
830         }
831
832         mirror[0] = tvec[0];
833         mirror[1] = tvec[1];
834         mirror[2] = (value_size > 2) ? tvec[2] : 0.0f;
835
836         vec[0] = self->vec[0];
837         vec[1] = self->vec[1];
838         vec[2] = (value_size > 2) ? self->vec[2] : 0.0f;
839
840         normalize_v3(mirror);
841         reflect_v3_v3v3(reflect, vec, mirror);
842
843         return Vector_CreatePyObject(reflect, self->size, Py_NEW, Py_TYPE(self));
844 }
845
846 PyDoc_STRVAR(Vector_cross_doc,
847 ".. method:: cross(other)\n"
848 "\n"
849 "   Return the cross product of this vector and another.\n"
850 "\n"
851 "   :arg other: The other vector to perform the cross product with.\n"
852 "   :type other: :class:`Vector`\n"
853 "   :return: The cross product.\n"
854 "   :rtype: :class:`Vector`\n"
855 "\n"
856 "   .. note:: both vectors must be 3D\n"
857 );
858 static PyObject *Vector_cross(VectorObject *self, PyObject *value)
859 {
860         VectorObject *ret;
861         float tvec[MAX_DIMENSIONS];
862
863         if (BaseMath_ReadCallback(self) == -1)
864                 return NULL;
865
866         if (mathutils_array_parse(tvec, self->size, self->size, value, "Vector.cross(other), invalid 'other' arg") == -1)
867                 return NULL;
868
869         if (self->size != 3) {
870                 PyErr_SetString(PyExc_ValueError,
871                                 "Vector must be 3D");
872                 return NULL;
873         }
874
875         ret = (VectorObject *)Vector_CreatePyObject(NULL, 3, Py_NEW, Py_TYPE(self));
876         cross_v3_v3v3(ret->vec, self->vec, tvec);
877         return (PyObject *)ret;
878 }
879
880 PyDoc_STRVAR(Vector_dot_doc,
881 ".. method:: dot(other)\n"
882 "\n"
883 "   Return the dot product of this vector and another.\n"
884 "\n"
885 "   :arg other: The other vector to perform the dot product with.\n"
886 "   :type other: :class:`Vector`\n"
887 "   :return: The dot product.\n"
888 "   :rtype: :class:`Vector`\n"
889 );
890 static PyObject *Vector_dot(VectorObject *self, PyObject *value)
891 {
892         float *tvec;
893
894         if (BaseMath_ReadCallback(self) == -1)
895                 return NULL;
896
897         if (mathutils_array_parse_alloc(&tvec, self->size, value, "Vector.dot(other), invalid 'other' arg") == -1) {
898                 goto cleanup;
899         }
900
901         return PyFloat_FromDouble(dot_vn_vn(self->vec, tvec, self->size));
902
903 cleanup:
904         PyMem_Free(tvec);
905         return NULL;
906 }
907
908 PyDoc_STRVAR(Vector_angle_doc,
909 ".. function:: angle(other, fallback)\n"
910 "\n"
911 "   Return the angle between two vectors.\n"
912 "\n"
913 "   :arg other: another vector to compare the angle with\n"
914 "   :type other: :class:`Vector`\n"
915 "   :arg fallback: return this value when the angle cant be calculated\n"
916 "      (zero length vector)\n"
917 "   :type fallback: any\n"
918 "   :return: angle in radians or fallback when given\n"
919 "   :rtype: float\n"
920 "\n"
921 "   .. note:: Zero length vectors raise an :exc:`ValueError`.\n"
922 );
923 static PyObject *Vector_angle(VectorObject *self, PyObject *args)
924 {
925         const int size = MIN2(self->size, 3); /* 4D angle makes no sense */
926         float tvec[MAX_DIMENSIONS];
927         PyObject *value;
928         double dot = 0.0f, dot_self = 0.0f, dot_other = 0.0f;
929         int x;
930         PyObject *fallback = NULL;
931
932         if (!PyArg_ParseTuple(args, "O|O:angle", &value, &fallback))
933                 return NULL;
934
935         if (BaseMath_ReadCallback(self) == -1)
936                 return NULL;
937
938         /* don't use clamped size, rule of thumb is vector sizes must match,
939          * even though n this case 'w' is ignored */
940         if (mathutils_array_parse(tvec, self->size, self->size, value, "Vector.angle(other), invalid 'other' arg") == -1)
941                 return NULL;
942
943         if (self->size > 4) {
944                 PyErr_SetString(PyExc_ValueError,
945                                 "Vector must be 2D, 3D or 4D");
946                 return NULL;
947         }
948
949         for (x = 0; x < size; x++) {
950                 dot_self  += (double)self->vec[x] * (double)self->vec[x];
951                 dot_other += (double)tvec[x]      * (double)tvec[x];
952                 dot       += (double)self->vec[x] * (double)tvec[x];
953         }
954
955         if (!dot_self || !dot_other) {
956                 /* avoid exception */
957                 if (fallback) {
958                         Py_INCREF(fallback);
959                         return fallback;
960                 }
961                 else {
962                         PyErr_SetString(PyExc_ValueError,
963                                         "Vector.angle(other): "
964                                         "zero length vectors have no valid angle");
965                         return NULL;
966                 }
967         }
968
969         return PyFloat_FromDouble(saacos(dot / (sqrt(dot_self) * sqrt(dot_other))));
970 }
971
972 PyDoc_STRVAR(Vector_angle_signed_doc,
973 ".. function:: angle_signed(other, fallback)\n"
974 "\n"
975 "   Return the signed angle between two 2D vectors (clockwise is positive).\n"
976 "\n"
977 "   :arg other: another vector to compare the angle with\n"
978 "   :type other: :class:`Vector`\n"
979 "   :arg fallback: return this value when the angle cant be calculated\n"
980 "      (zero length vector)\n"
981 "   :type fallback: any\n"
982 "   :return: angle in radians or fallback when given\n"
983 "   :rtype: float\n"
984 "\n"
985 "   .. note:: Zero length vectors raise an :exc:`ValueError`.\n"
986 );
987 static PyObject *Vector_angle_signed(VectorObject *self, PyObject *args)
988 {
989         float tvec[2];
990
991         PyObject *value;
992         PyObject *fallback = NULL;
993
994         if (!PyArg_ParseTuple(args, "O|O:angle_signed", &value, &fallback))
995                 return NULL;
996
997         if (BaseMath_ReadCallback(self) == -1)
998                 return NULL;
999
1000         if (mathutils_array_parse(tvec, 2, 2, value, "Vector.angle_signed(other), invalid 'other' arg") == -1)
1001                 return NULL;
1002
1003         if (self->size != 2) {
1004                 PyErr_SetString(PyExc_ValueError,
1005                                 "Vector must be 2D");
1006                 return NULL;
1007         }
1008
1009         if (is_zero_v2(self->vec) || is_zero_v2(tvec)) {
1010                 /* avoid exception */
1011                 if (fallback) {
1012                         Py_INCREF(fallback);
1013                         return fallback;
1014                 }
1015                 else {
1016                         PyErr_SetString(PyExc_ValueError,
1017                                         "Vector.angle_signed(other): "
1018                                         "zero length vectors have no valid angle");
1019                         return NULL;
1020                 }
1021         }
1022
1023
1024         return PyFloat_FromDouble(angle_signed_v2v2(self->vec, tvec));
1025 }
1026
1027
1028 PyDoc_STRVAR(Vector_rotation_difference_doc,
1029 ".. function:: rotation_difference(other)\n"
1030 "\n"
1031 "   Returns a quaternion representing the rotational difference between this\n"
1032 "   vector and another.\n"
1033 "\n"
1034 "   :arg other: second vector.\n"
1035 "   :type other: :class:`Vector`\n"
1036 "   :return: the rotational difference between the two vectors.\n"
1037 "   :rtype: :class:`Quaternion`\n"
1038 "\n"
1039 "   .. note:: 2D vectors raise an :exc:`AttributeError`.\n"
1040 );
1041 static PyObject *Vector_rotation_difference(VectorObject *self, PyObject *value)
1042 {
1043         float quat[4], vec_a[3], vec_b[3];
1044
1045         if (self->size < 3 || self->size > 4) {
1046                 PyErr_SetString(PyExc_ValueError,
1047                                 "vec.difference(value): "
1048                                 "expects both vectors to be size 3 or 4");
1049                 return NULL;
1050         }
1051
1052         if (BaseMath_ReadCallback(self) == -1)
1053                 return NULL;
1054
1055         if (mathutils_array_parse(vec_b, 3, MAX_DIMENSIONS, value, "Vector.difference(other), invalid 'other' arg") == -1)
1056                 return NULL;
1057
1058         normalize_v3_v3(vec_a, self->vec);
1059         normalize_v3(vec_b);
1060
1061         rotation_between_vecs_to_quat(quat, vec_a, vec_b);
1062
1063         return Quaternion_CreatePyObject(quat, Py_NEW, NULL);
1064 }
1065
1066 PyDoc_STRVAR(Vector_project_doc,
1067 ".. function:: project(other)\n"
1068 "\n"
1069 "   Return the projection of this vector onto the *other*.\n"
1070 "\n"
1071 "   :arg other: second vector.\n"
1072 "   :type other: :class:`Vector`\n"
1073 "   :return: the parallel projection vector\n"
1074 "   :rtype: :class:`Vector`\n"
1075 );
1076 static PyObject *Vector_project(VectorObject *self, PyObject *value)
1077 {
1078         const int size = self->size;
1079         float tvec[MAX_DIMENSIONS];
1080         float vec[MAX_DIMENSIONS];
1081         double dot = 0.0f, dot2 = 0.0f;
1082         int x;
1083
1084         if (BaseMath_ReadCallback(self) == -1)
1085                 return NULL;
1086
1087         if (mathutils_array_parse(tvec, size, size, value, "Vector.project(other), invalid 'other' arg") == -1)
1088                 return NULL;
1089
1090         if (self->size > 4) {
1091                 PyErr_SetString(PyExc_ValueError,
1092                                 "Vector must be 2D, 3D or 4D");
1093                 return NULL;
1094         }
1095
1096         if (BaseMath_ReadCallback(self) == -1)
1097                 return NULL;
1098
1099         //get dot products
1100         for (x = 0; x < size; x++) {
1101                 dot += (double)(self->vec[x] * tvec[x]);
1102                 dot2 += (double)(tvec[x] * tvec[x]);
1103         }
1104         //projection
1105         dot /= dot2;
1106         for (x = 0; x < size; x++) {
1107                 vec[x] = (float)dot * tvec[x];
1108         }
1109         return Vector_CreatePyObject(vec, size, Py_NEW, Py_TYPE(self));
1110 }
1111
1112 PyDoc_STRVAR(Vector_lerp_doc,
1113 ".. function:: lerp(other, factor)\n"
1114 "\n"
1115 "   Returns the interpolation of two vectors.\n"
1116 "\n"
1117 "   :arg other: value to interpolate with.\n"
1118 "   :type other: :class:`Vector`\n"
1119 "   :arg factor: The interpolation value in [0.0, 1.0].\n"
1120 "   :type factor: float\n"
1121 "   :return: The interpolated rotation.\n"
1122 "   :rtype: :class:`Vector`\n"
1123 );
1124 static PyObject *Vector_lerp(VectorObject *self, PyObject *args)
1125 {
1126         const int size = self->size;
1127         PyObject *value = NULL;
1128         float fac, ifac;
1129         float *tvec, *vec;
1130         int x;
1131
1132         if (!PyArg_ParseTuple(args, "Of:lerp", &value, &fac))
1133                 return NULL;
1134
1135         if (mathutils_array_parse_alloc(&tvec, size, value, "Vector.lerp(other), invalid 'other' arg") == -1) {
1136                 goto cleanup;
1137         }
1138
1139         if (BaseMath_ReadCallback(self) == -1) {
1140                 goto cleanup;
1141         }
1142
1143         vec = PyMem_Malloc(size * sizeof(float));
1144         if (vec == NULL) {
1145                 PyErr_SetString(PyExc_MemoryError,
1146                                 "Vector.lerp(): "
1147                                 "problem allocating pointer space");
1148                 return NULL;
1149         }
1150
1151         ifac = 1.0f - fac;
1152
1153         for (x = 0; x < size; x++) {
1154                 vec[x] = (ifac * self->vec[x]) + (fac * tvec[x]);
1155         }
1156
1157         PyMem_Free(tvec);
1158
1159         return Vector_CreatePyObject_alloc(vec, size, Py_TYPE(self));
1160
1161 cleanup:
1162         PyMem_Free(tvec);
1163         return NULL;
1164 }
1165
1166 PyDoc_STRVAR(Vector_rotate_doc,
1167 ".. function:: rotate(other)\n"
1168 "\n"
1169 "   Return vector by a rotation value.\n"
1170 "\n"
1171 "   :arg other: rotation component of mathutils value\n"
1172 "   :type other: :class:`Euler`, :class:`Quaternion` or :class:`Matrix`\n"
1173 );
1174 static PyObject *Vector_rotate(VectorObject *self, PyObject *value)
1175 {
1176         float other_rmat[3][3];
1177
1178         if (BaseMath_ReadCallback(self) == -1)
1179                 return NULL;
1180
1181         if (mathutils_any_to_rotmat(other_rmat, value, "Vector.rotate(value)") == -1)
1182                 return NULL;
1183
1184         if (self->size < 3 || self->size > 4) {
1185                 PyErr_SetString(PyExc_ValueError,
1186                                 "Vector must be 3D or 4D");
1187                 return NULL;
1188         }
1189
1190         mul_m3_v3(other_rmat, self->vec);
1191
1192         (void)BaseMath_WriteCallback(self);
1193         Py_RETURN_NONE;
1194 }
1195
1196 PyDoc_STRVAR(Vector_copy_doc,
1197 ".. function:: copy()\n"
1198 "\n"
1199 "   Returns a copy of this vector.\n"
1200 "\n"
1201 "   :return: A copy of the vector.\n"
1202 "   :rtype: :class:`Vector`\n"
1203 "\n"
1204 "   .. note:: use this to get a copy of a wrapped vector with\n"
1205 "      no reference to the original data.\n"
1206 );
1207 static PyObject *Vector_copy(VectorObject *self)
1208 {
1209         if (BaseMath_ReadCallback(self) == -1)
1210                 return NULL;
1211
1212         return Vector_CreatePyObject(self->vec, self->size, Py_NEW, Py_TYPE(self));
1213 }
1214
1215 static PyObject *Vector_repr(VectorObject *self)
1216 {
1217         PyObject *ret, *tuple;
1218
1219         if (BaseMath_ReadCallback(self) == -1)
1220                 return NULL;
1221
1222         tuple = Vector_to_tuple_ext(self, -1);
1223         ret = PyUnicode_FromFormat("Vector(%R)", tuple);
1224         Py_DECREF(tuple);
1225         return ret;
1226 }
1227
1228 static PyObject *Vector_str(VectorObject *self)
1229 {
1230         int i;
1231
1232         DynStr *ds;
1233
1234         if (BaseMath_ReadCallback(self) == -1)
1235                 return NULL;
1236
1237         ds = BLI_dynstr_new();
1238
1239         BLI_dynstr_append(ds, "<Vector (");
1240
1241         for (i = 0; i < self->size; i++) {
1242                 BLI_dynstr_appendf(ds, i ? ", %.4f" : "%.4f", self->vec[i]);
1243         }
1244
1245         BLI_dynstr_append(ds, ")>");
1246
1247         return mathutils_dynstr_to_py(ds); /* frees ds */
1248 }
1249
1250
1251 /* Sequence Protocol */
1252 /* sequence length len(vector) */
1253 static int Vector_len(VectorObject *self)
1254 {
1255         return self->size;
1256 }
1257 /* sequence accessor (get): vector[index] */
1258 static PyObject *vector_item_internal(VectorObject *self, int i, const int is_attr)
1259 {
1260         if (i < 0) i = self->size - i;
1261
1262         if (i < 0 || i >= self->size) {
1263                 if (is_attr) {
1264                         PyErr_Format(PyExc_AttributeError,
1265                                      "Vector.%c: unavailable on %dd vector",
1266                                      *(((char *)"xyzw") + i), self->size);
1267                 }
1268                 else {
1269                         PyErr_SetString(PyExc_IndexError,
1270                                         "vector[index]: out of range");
1271                 }
1272                 return NULL;
1273         }
1274
1275         if (BaseMath_ReadIndexCallback(self, i) == -1)
1276                 return NULL;
1277
1278         return PyFloat_FromDouble(self->vec[i]);
1279 }
1280
1281 static PyObject *Vector_item(VectorObject *self, int i)
1282 {
1283         return vector_item_internal(self, i, FALSE);
1284 }
1285 /* sequence accessor (set): vector[index] = value */
1286 static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value, const int is_attr)
1287 {
1288         float scalar;
1289         if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
1290                 PyErr_SetString(PyExc_TypeError,
1291                                 "vector[index] = x: "
1292                                 "index argument not a number");
1293                 return -1;
1294         }
1295
1296         if (i < 0) i = self->size - i;
1297
1298         if (i < 0 || i >= self->size) {
1299                 if (is_attr) {
1300                         PyErr_Format(PyExc_AttributeError,
1301                                      "Vector.%c = x: unavailable on %dd vector",
1302                                      *(((char *)"xyzw") + i), self->size);
1303                 }
1304                 else {
1305                         PyErr_SetString(PyExc_IndexError,
1306                                         "vector[index] = x: "
1307                                         "assignment index out of range");
1308                 }
1309                 return -1;
1310         }
1311         self->vec[i] = scalar;
1312
1313         if (BaseMath_WriteIndexCallback(self, i) == -1)
1314                 return -1;
1315         return 0;
1316 }
1317
1318 static int Vector_ass_item(VectorObject *self, int i, PyObject *value)
1319 {
1320         return vector_ass_item_internal(self, i, value, FALSE);
1321 }
1322
1323 /* sequence slice (get): vector[a:b] */
1324 static PyObject *Vector_slice(VectorObject *self, int begin, int end)
1325 {
1326         PyObject *tuple;
1327         int count;
1328
1329         if (BaseMath_ReadCallback(self) == -1)
1330                 return NULL;
1331
1332         CLAMP(begin, 0, self->size);
1333         if (end < 0) end = self->size + end + 1;
1334         CLAMP(end, 0, self->size);
1335         begin = MIN2(begin, end);
1336
1337         tuple = PyTuple_New(end - begin);
1338         for (count = begin; count < end; count++) {
1339                 PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->vec[count]));
1340         }
1341
1342         return tuple;
1343 }
1344 /* sequence slice (set): vector[a:b] = value */
1345 static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *seq)
1346 {
1347         int size = 0;
1348         float *vec = NULL;
1349
1350         if (BaseMath_ReadCallback(self) == -1)
1351                 return -1;
1352
1353         CLAMP(begin, 0, self->size);
1354         CLAMP(end, 0, self->size);
1355         begin = MIN2(begin, end);
1356
1357         size = (end - begin);
1358         if (mathutils_array_parse_alloc(&vec, size, seq, "vector[begin:end] = [...]") == -1) {
1359                 goto cleanup;
1360         }
1361
1362         if (vec == NULL) {
1363                 PyErr_SetString(PyExc_MemoryError,
1364                                 "vec[:] = seq: "
1365                                 "problem allocating pointer space");
1366                 return -1;
1367         }
1368
1369         /*parsed well - now set in vector*/
1370         memcpy(self->vec + begin, vec, size * sizeof(float));
1371
1372         if (BaseMath_WriteCallback(self) == -1)
1373                 return -1;
1374
1375         PyMem_Free(vec);
1376
1377         return 0;
1378
1379 cleanup:
1380         PyMem_Free(vec);
1381         return -1;
1382 }
1383
1384 /* Numeric Protocols */
1385 /* addition: obj + obj */
1386 static PyObject *Vector_add(PyObject *v1, PyObject *v2)
1387 {
1388         VectorObject *vec1 = NULL, *vec2 = NULL;
1389         float *vec = NULL;
1390
1391         if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
1392                 PyErr_Format(PyExc_AttributeError,
1393                              "Vector addition: (%s + %s) "
1394                              "invalid type for this operation",
1395                              Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
1396                 return NULL;
1397         }
1398         vec1 = (VectorObject *)v1;
1399         vec2 = (VectorObject *)v2;
1400
1401         if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1)
1402                 return NULL;
1403
1404         /*VECTOR + VECTOR*/
1405         if (vec1->size != vec2->size) {
1406                 PyErr_SetString(PyExc_AttributeError,
1407                                 "Vector addition: "
1408                                 "vectors must have the same dimensions for this operation");
1409                 return NULL;
1410         }
1411
1412         vec = PyMem_Malloc(vec1->size * sizeof(float));
1413
1414         if (vec == NULL) { /*allocation failure*/
1415                 PyErr_SetString(PyExc_MemoryError,
1416                                 "Vector(): "
1417                                 "problem allocating pointer space");
1418                 return NULL;
1419         }
1420
1421         add_vn_vnvn(vec, vec1->vec, vec2->vec, vec1->size);
1422
1423         return Vector_CreatePyObject_alloc(vec, vec1->size, Py_TYPE(v1));
1424 }
1425
1426 /* addition in-place: obj += obj */
1427 static PyObject *Vector_iadd(PyObject *v1, PyObject *v2)
1428 {
1429         VectorObject *vec1 = NULL, *vec2 = NULL;
1430
1431         if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
1432                 PyErr_Format(PyExc_AttributeError,
1433                              "Vector addition: (%s += %s) "
1434                              "invalid type for this operation",
1435                              Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
1436                 return NULL;
1437         }
1438         vec1 = (VectorObject *)v1;
1439         vec2 = (VectorObject *)v2;
1440
1441         if (vec1->size != vec2->size) {
1442                 PyErr_SetString(PyExc_AttributeError,
1443                                 "Vector addition: "
1444                                 "vectors must have the same dimensions for this operation");
1445                 return NULL;
1446         }
1447
1448         if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1)
1449                 return NULL;
1450
1451         add_vn_vn(vec1->vec, vec2->vec, vec1->size);
1452
1453         (void)BaseMath_WriteCallback(vec1);
1454         Py_INCREF(v1);
1455         return v1;
1456 }
1457
1458 /* subtraction: obj - obj */
1459 static PyObject *Vector_sub(PyObject *v1, PyObject *v2)
1460 {
1461         VectorObject *vec1 = NULL, *vec2 = NULL;
1462         float *vec;
1463
1464         if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
1465                 PyErr_Format(PyExc_AttributeError,
1466                              "Vector subtraction: (%s - %s) "
1467                              "invalid type for this operation",
1468                              Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
1469                 return NULL;
1470         }
1471         vec1 = (VectorObject *)v1;
1472         vec2 = (VectorObject *)v2;
1473
1474         if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1)
1475                 return NULL;
1476
1477         if (vec1->size != vec2->size) {
1478                 PyErr_SetString(PyExc_AttributeError,
1479                                 "Vector subtraction: "
1480                                 "vectors must have the same dimensions for this operation");
1481                 return NULL;
1482         }
1483
1484         vec = PyMem_Malloc(vec1->size * sizeof(float));
1485
1486         if (vec == NULL) { /*allocation failure*/
1487                 PyErr_SetString(PyExc_MemoryError,
1488                                 "Vector(): "
1489                                 "problem allocating pointer space");
1490                 return NULL;
1491         }
1492
1493         sub_vn_vnvn(vec, vec1->vec, vec2->vec, vec1->size);
1494
1495         return Vector_CreatePyObject_alloc(vec, vec1->size, Py_TYPE(v1));
1496 }
1497
1498 /* subtraction in-place: obj -= obj */
1499 static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
1500 {
1501         VectorObject *vec1 = NULL, *vec2 = NULL;
1502
1503         if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
1504                 PyErr_Format(PyExc_AttributeError,
1505                              "Vector subtraction: (%s -= %s) "
1506                              "invalid type for this operation",
1507                              Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
1508                 return NULL;
1509         }
1510         vec1 = (VectorObject *)v1;
1511         vec2 = (VectorObject *)v2;
1512
1513         if (vec1->size != vec2->size) {
1514                 PyErr_SetString(PyExc_AttributeError,
1515                                 "Vector subtraction: "
1516                                 "vectors must have the same dimensions for this operation");
1517                 return NULL;
1518         }
1519
1520         if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1)
1521                 return NULL;
1522
1523         sub_vn_vn(vec1->vec, vec2->vec, vec1->size);
1524
1525         (void)BaseMath_WriteCallback(vec1);
1526         Py_INCREF(v1);
1527         return v1;
1528 }
1529
1530 /*------------------------obj * obj------------------------------
1531  * mulplication*/
1532
1533
1534 /* COLUMN VECTOR Multiplication (Matrix X Vector)
1535  * [1][4][7]   [a]
1536  * [2][5][8] * [b]
1537  * [3][6][9]   [c]
1538  *
1539  * note: vector/matrix multiplication IS NOT COMMUTATIVE!!!!
1540  * note: assume read callbacks have been done first.
1541  */
1542 int column_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject *vec, MatrixObject *mat)
1543 {
1544         float vec_cpy[MAX_DIMENSIONS];
1545         int row, col, z = 0;
1546
1547         if (mat->num_col != vec->size) {
1548                 if (mat->num_col == 4 && vec->size == 3) {
1549                         vec_cpy[3] = 1.0f;
1550                 }
1551                 else {
1552                         PyErr_SetString(PyExc_ValueError,
1553                                         "matrix * vector: "
1554                                         "len(matrix.col) and len(vector) must be the same, "
1555                                         "except for 4x4 matrix * 3D vector.");
1556                         return -1;
1557                 }
1558         }
1559
1560         memcpy(vec_cpy, vec->vec, vec->size * sizeof(float));
1561
1562         r_vec[3] = 1.0f;
1563
1564         for (row = 0; row < mat->num_row; row++) {
1565                 double dot = 0.0f;
1566                 for (col = 0; col < mat->num_col; col++) {
1567                         dot += (double)(MATRIX_ITEM(mat, row, col) * vec_cpy[col]);
1568                 }
1569                 r_vec[z++] = (float)dot;
1570         }
1571
1572         return 0;
1573 }
1574
1575 static PyObject *vector_mul_float(VectorObject *vec, const float scalar)
1576 {
1577         float *tvec = PyMem_Malloc(vec->size * sizeof(float));
1578
1579         if (tvec == NULL) { /*allocation failure*/
1580                 PyErr_SetString(PyExc_MemoryError,
1581                                 "vec * float: "
1582                                 "problem allocating pointer space");
1583                 return NULL;
1584         }
1585
1586         mul_vn_vn_fl(tvec, vec->vec, vec->size, scalar);
1587         return Vector_CreatePyObject_alloc(tvec, vec->size, Py_TYPE(vec));
1588 }
1589
1590 static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
1591 {
1592         VectorObject *vec1 = NULL, *vec2 = NULL;
1593         float scalar;
1594         int vec_size;
1595
1596         if (VectorObject_Check(v1)) {
1597                 vec1 = (VectorObject *)v1;
1598                 if (BaseMath_ReadCallback(vec1) == -1)
1599                         return NULL;
1600         }
1601         if (VectorObject_Check(v2)) {
1602                 vec2 = (VectorObject *)v2;
1603                 if (BaseMath_ReadCallback(vec2) == -1)
1604                         return NULL;
1605         }
1606
1607
1608         /* make sure v1 is always the vector */
1609         if (vec1 && vec2) {
1610                 if (vec1->size != vec2->size) {
1611                         PyErr_SetString(PyExc_ValueError,
1612                                         "Vector multiplication: "
1613                                         "vectors must have the same dimensions for this operation");
1614                         return NULL;
1615                 }
1616
1617                 /*dot product*/
1618                 return PyFloat_FromDouble(dot_vn_vn(vec1->vec, vec2->vec, vec1->size));
1619         }
1620         else if (vec1) {
1621                 if (MatrixObject_Check(v2)) {
1622                         /* VEC * MATRIX */
1623                         float tvec[MAX_DIMENSIONS];
1624
1625                         if (BaseMath_ReadCallback((MatrixObject *)v2) == -1)
1626                                 return NULL;
1627                         if (row_vector_multiplication(tvec, vec1, (MatrixObject *)v2) == -1) {
1628                                 return NULL;
1629                         }
1630
1631                         if (((MatrixObject *)v2)->num_row == 4 && vec1->size == 3) {
1632                                 vec_size = 3;
1633                         }
1634                         else {
1635                                 vec_size = ((MatrixObject *)v2)->num_col;
1636                         }
1637
1638                         return Vector_CreatePyObject(tvec, vec_size, Py_NEW, Py_TYPE(vec1));
1639                 }
1640                 else if (QuaternionObject_Check(v2)) {
1641                         /* VEC * QUAT */
1642 /* ------ to be removed ------*/
1643 #if 1
1644                         PyErr_SetString(PyExc_ValueError,
1645                                         "(Vector * Quat) is now removed, reverse the "
1646                                         "order (promoted to an Error for Debug builds)");
1647                         return NULL;
1648 #else
1649                         QuaternionObject *quat2 = (QuaternionObject *)v2;
1650                         float tvec[3];
1651
1652                         if (vec1->size != 3) {
1653                                 PyErr_SetString(PyExc_ValueError,
1654                                                 "Vector multiplication: "
1655                                                 "only 3D vector rotations (with quats) currently supported");
1656                                 return NULL;
1657                         }
1658                         if (BaseMath_ReadCallback(quat2) == -1) {
1659                                 return NULL;
1660                         }
1661
1662                         copy_v3_v3(tvec, vec1->vec);
1663                         mul_qt_v3(quat2->quat, tvec);
1664                         return Vector_CreatePyObject(tvec, 3, Py_NEW, Py_TYPE(vec1));
1665 #endif
1666 /* ------ to be removed ------*/
1667                 }
1668                 else if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* VEC * FLOAT */
1669                         return vector_mul_float(vec1, scalar);
1670                 }
1671         }
1672         else if (vec2) {
1673                 if (((scalar = PyFloat_AsDouble(v1)) == -1.0f && PyErr_Occurred()) == 0) { /* FLOAT * VEC */
1674                         return vector_mul_float(vec2, scalar);
1675                 }
1676         }
1677         else {
1678                 BLI_assert(!"internal error");
1679         }
1680
1681         PyErr_Format(PyExc_TypeError,
1682                      "Vector multiplication: "
1683                      "not supported between '%.200s' and '%.200s' types",
1684                      Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
1685         return NULL;
1686 }
1687
1688 /* mulplication in-place: obj *= obj */
1689 static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
1690 {
1691         VectorObject *vec = (VectorObject *)v1;
1692         float scalar;
1693
1694         if (BaseMath_ReadCallback(vec) == -1)
1695                 return NULL;
1696
1697         /* only support vec*=float and vec*=mat
1698          *  vec*=vec result is a float so that wont work */
1699         if (MatrixObject_Check(v2)) {
1700 /* ------ to be removed ------*/
1701 #if 1
1702                 PyErr_SetString(PyExc_ValueError,
1703                                 "(Vector *= Matrix) is now removed, reverse the "
1704                                 "order (promoted to an Error for Debug builds) "
1705                                 "and uses the non in-place multiplication.");
1706                 return NULL;
1707 #else
1708                 float rvec[MAX_DIMENSIONS];
1709                 if (BaseMath_ReadCallback((MatrixObject *)v2) == -1)
1710                         return NULL;
1711
1712                 if (column_vector_multiplication(rvec, vec, (MatrixObject *)v2) == -1)
1713                         return NULL;
1714
1715                 memcpy(vec->vec, rvec, sizeof(float) * vec->size);
1716 #endif
1717 /* ------ to be removed ------*/
1718         }
1719         else if (QuaternionObject_Check(v2)) {
1720                 /* VEC *= QUAT */
1721
1722 /* ------ to be removed ------*/
1723 #if 1
1724                 PyErr_SetString(PyExc_ValueError,
1725                                 "(Vector *= Quat) is now removed, reverse the "
1726                                 "order (promoted to an Error for Debug builds) "
1727                                 "and uses the non in-place multiplication.");
1728                 return NULL;
1729 #else
1730                 QuaternionObject *quat2 = (QuaternionObject *)v2;
1731
1732                 if (vec->size != 3) {
1733                         PyErr_SetString(PyExc_ValueError,
1734                                         "Vector multiplication: "
1735                                         "only 3D vector rotations (with quats) currently supported");
1736                         return NULL;
1737                 }
1738
1739                 if (BaseMath_ReadCallback(quat2) == -1) {
1740                         return NULL;
1741                 }
1742
1743                 mul_qt_v3(quat2->quat, vec->vec);
1744 #endif
1745 /* ------ to be removed ------*/
1746         }
1747         else if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* VEC *= FLOAT */
1748                 mul_vn_fl(vec->vec, vec->size, scalar);
1749         }
1750         else {
1751                 PyErr_Format(PyExc_TypeError,
1752                              "Vector multiplication: (%s *= %s) "
1753                              "invalid type for this operation",
1754                              Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
1755                 return NULL;
1756         }
1757
1758         (void)BaseMath_WriteCallback(vec);
1759         Py_INCREF(v1);
1760         return v1;
1761 }
1762
1763 /* divid: obj / obj */
1764 static PyObject *Vector_div(PyObject *v1, PyObject *v2)
1765 {
1766         float *vec = NULL, scalar;
1767         VectorObject *vec1 = NULL;
1768
1769         if (!VectorObject_Check(v1)) { /* not a vector */
1770                 PyErr_SetString(PyExc_TypeError,
1771                                 "Vector division: "
1772                                 "Vector must be divided by a float");
1773                 return NULL;
1774         }
1775         vec1 = (VectorObject *)v1; /* vector */
1776
1777         if (BaseMath_ReadCallback(vec1) == -1)
1778                 return NULL;
1779
1780         if ((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
1781                 PyErr_SetString(PyExc_TypeError,
1782                                 "Vector division: "
1783                                 "Vector must be divided by a float");
1784                 return NULL;
1785         }
1786
1787         if (scalar == 0.0f) {
1788                 PyErr_SetString(PyExc_ZeroDivisionError,
1789                                 "Vector division: "
1790                                 "divide by zero error");
1791                 return NULL;
1792         }
1793
1794         vec = PyMem_Malloc(vec1->size * sizeof(float));
1795
1796         if (vec == NULL) { /*allocation failure*/
1797                 PyErr_SetString(PyExc_MemoryError,
1798                                 "vec / value: "
1799                                 "problem allocating pointer space");
1800                 return NULL;
1801         }
1802
1803         mul_vn_vn_fl(vec, vec1->vec, vec1->size, 1.0f / scalar);
1804
1805         return Vector_CreatePyObject_alloc(vec, vec1->size, Py_TYPE(v1));
1806 }
1807
1808 /* divide in-place: obj /= obj */
1809 static PyObject *Vector_idiv(PyObject *v1, PyObject *v2)
1810 {
1811         float scalar;
1812         VectorObject *vec1 = (VectorObject *)v1;
1813
1814         if (BaseMath_ReadCallback(vec1) == -1)
1815                 return NULL;
1816
1817         if ((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
1818                 PyErr_SetString(PyExc_TypeError,
1819                                 "Vector division: "
1820                                 "Vector must be divided by a float");
1821                 return NULL;
1822         }
1823
1824         if (scalar == 0.0f) {
1825                 PyErr_SetString(PyExc_ZeroDivisionError,
1826                                 "Vector division: "
1827                                 "divide by zero error");
1828                 return NULL;
1829         }
1830
1831         mul_vn_fl(vec1->vec, vec1->size, 1.0f / scalar);
1832
1833         (void)BaseMath_WriteCallback(vec1);
1834
1835         Py_INCREF(v1);
1836         return v1;
1837 }
1838
1839 /* -obj
1840  * returns the negative of this object*/
1841 static PyObject *Vector_neg(VectorObject *self)
1842 {
1843         float *tvec;
1844
1845         if (BaseMath_ReadCallback(self) == -1)
1846                 return NULL;
1847
1848         tvec = PyMem_Malloc(self->size * sizeof(float));
1849         negate_vn_vn(tvec, self->vec, self->size);
1850         return Vector_CreatePyObject_alloc(tvec, self->size, Py_TYPE(self));
1851 }
1852
1853 /*------------------------vec_magnitude_nosqrt (internal) - for comparing only */
1854 static double vec_magnitude_nosqrt(float *data, int size)
1855 {
1856         /* return (double)sqrt(dot);*/
1857         /* warning, line above removed because we are not using the length,
1858          * rather the comparing the sizes and for this we do not need the sqrt
1859          * for the actual length, the dot must be sqrt'd */
1860         return dot_vn_vn(data, data, size);
1861 }
1862
1863
1864 /*------------------------tp_richcmpr
1865  * returns -1 execption, 0 false, 1 true */
1866 static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_type)
1867 {
1868         VectorObject *vecA = NULL, *vecB = NULL;
1869         int result = 0;
1870         double epsilon = .000001f;
1871         double lenA, lenB;
1872
1873         if (!VectorObject_Check(objectA) || !VectorObject_Check(objectB)) {
1874                 if (comparison_type == Py_NE) {
1875                         Py_RETURN_TRUE;
1876                 }
1877                 else {
1878                         Py_RETURN_FALSE;
1879                 }
1880         }
1881         vecA = (VectorObject *)objectA;
1882         vecB = (VectorObject *)objectB;
1883
1884         if (BaseMath_ReadCallback(vecA) == -1 || BaseMath_ReadCallback(vecB) == -1)
1885                 return NULL;
1886
1887         if (vecA->size != vecB->size) {
1888                 if (comparison_type == Py_NE) {
1889                         Py_RETURN_TRUE;
1890                 }
1891                 else {
1892                         Py_RETURN_FALSE;
1893                 }
1894         }
1895
1896         switch (comparison_type) {
1897                 case Py_LT:
1898                         lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
1899                         lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
1900                         if (lenA < lenB) {
1901                                 result = 1;
1902                         }
1903                         break;
1904                 case Py_LE:
1905                         lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
1906                         lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
1907                         if (lenA < lenB) {
1908                                 result = 1;
1909                         }
1910                         else {
1911                                 result = (((lenA + epsilon) > lenB) && ((lenA - epsilon) < lenB));
1912                         }
1913                         break;
1914                 case Py_EQ:
1915                         result = EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->size, 1);
1916                         break;
1917                 case Py_NE:
1918                         result = !EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->size, 1);
1919                         break;
1920                 case Py_GT:
1921                         lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
1922                         lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
1923                         if (lenA > lenB) {
1924                                 result = 1;
1925                         }
1926                         break;
1927                 case Py_GE:
1928                         lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
1929                         lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
1930                         if (lenA > lenB) {
1931                                 result = 1;
1932                         }
1933                         else {
1934                                 result = (((lenA + epsilon) > lenB) && ((lenA - epsilon) < lenB));
1935                         }
1936                         break;
1937                 default:
1938                         printf("The result of the comparison could not be evaluated");
1939                         break;
1940         }
1941         if (result == 1) {
1942                 Py_RETURN_TRUE;
1943         }
1944         else {
1945                 Py_RETURN_FALSE;
1946         }
1947 }
1948
1949 /*-----------------PROTCOL DECLARATIONS--------------------------*/
1950 static PySequenceMethods Vector_SeqMethods = {
1951         (lenfunc) Vector_len,               /* sq_length */
1952         (binaryfunc) NULL,                  /* sq_concat */
1953         (ssizeargfunc) NULL,                /* sq_repeat */
1954         (ssizeargfunc) Vector_item,         /* sq_item */
1955         NULL,                               /* py3 deprecated slice func */
1956         (ssizeobjargproc) Vector_ass_item,  /* sq_ass_item */
1957         NULL,                               /* py3 deprecated slice assign func */
1958         (objobjproc) NULL,                  /* sq_contains */
1959         (binaryfunc) NULL,                  /* sq_inplace_concat */
1960         (ssizeargfunc) NULL,                /* sq_inplace_repeat */
1961 };
1962
1963 static PyObject *Vector_subscript(VectorObject *self, PyObject *item)
1964 {
1965         if (PyIndex_Check(item)) {
1966                 Py_ssize_t i;
1967                 i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1968                 if (i == -1 && PyErr_Occurred())
1969                         return NULL;
1970                 if (i < 0)
1971                         i += self->size;
1972                 return Vector_item(self, i);
1973         }
1974         else if (PySlice_Check(item)) {
1975                 Py_ssize_t start, stop, step, slicelength;
1976
1977                 if (PySlice_GetIndicesEx((void *)item, self->size, &start, &stop, &step, &slicelength) < 0)
1978                         return NULL;
1979
1980                 if (slicelength <= 0) {
1981                         return PyTuple_New(0);
1982                 }
1983                 else if (step == 1) {
1984                         return Vector_slice(self, start, stop);
1985                 }
1986                 else {
1987                         PyErr_SetString(PyExc_IndexError,
1988                                         "slice steps not supported with vectors");
1989                         return NULL;
1990                 }
1991         }
1992         else {
1993                 PyErr_Format(PyExc_TypeError,
1994                              "vector indices must be integers, not %.200s",
1995                              Py_TYPE(item)->tp_name);
1996                 return NULL;
1997         }
1998 }
1999
2000 static int Vector_ass_subscript(VectorObject *self, PyObject *item, PyObject *value)
2001 {
2002         if (PyIndex_Check(item)) {
2003                 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
2004                 if (i == -1 && PyErr_Occurred())
2005                         return -1;
2006                 if (i < 0)
2007                         i += self->size;
2008                 return Vector_ass_item(self, i, value);
2009         }
2010         else if (PySlice_Check(item)) {
2011                 Py_ssize_t start, stop, step, slicelength;
2012
2013                 if (PySlice_GetIndicesEx((void *)item, self->size, &start, &stop, &step, &slicelength) < 0)
2014                         return -1;
2015
2016                 if (step == 1)
2017                         return Vector_ass_slice(self, start, stop, value);
2018                 else {
2019                         PyErr_SetString(PyExc_IndexError,
2020                                         "slice steps not supported with vectors");
2021                         return -1;
2022                 }
2023         }
2024         else {
2025                 PyErr_Format(PyExc_TypeError,
2026                              "vector indices must be integers, not %.200s",
2027                              Py_TYPE(item)->tp_name);
2028                 return -1;
2029         }
2030 }
2031
2032 static PyMappingMethods Vector_AsMapping = {
2033         (lenfunc)Vector_len,
2034         (binaryfunc)Vector_subscript,
2035         (objobjargproc)Vector_ass_subscript
2036 };
2037
2038
2039 static PyNumberMethods Vector_NumMethods = {
2040         (binaryfunc)    Vector_add, /*nb_add*/
2041         (binaryfunc)    Vector_sub, /*nb_subtract*/
2042         (binaryfunc)    Vector_mul, /*nb_multiply*/
2043         NULL,                       /*nb_remainder*/
2044         NULL,                       /*nb_divmod*/
2045         NULL,                       /*nb_power*/
2046         (unaryfunc)     Vector_neg, /*nb_negative*/
2047         (unaryfunc)     NULL,       /*tp_positive*/
2048         (unaryfunc)     NULL,       /*tp_absolute*/
2049         (inquiry)   NULL,           /*tp_bool*/
2050         (unaryfunc) NULL,           /*nb_invert*/
2051         NULL,                       /*nb_lshift*/
2052         (binaryfunc)NULL,           /*nb_rshift*/
2053         NULL,                       /*nb_and*/
2054         NULL,                       /*nb_xor*/
2055         NULL,                       /*nb_or*/
2056         NULL,                       /*nb_int*/
2057         NULL,                       /*nb_reserved*/
2058         NULL,                       /*nb_float*/
2059         Vector_iadd,                /* nb_inplace_add */
2060         Vector_isub,                /* nb_inplace_subtract */
2061         Vector_imul,                /* nb_inplace_multiply */
2062         NULL,                       /* nb_inplace_remainder */
2063         NULL,                       /* nb_inplace_power */
2064         NULL,                       /* nb_inplace_lshift */
2065         NULL,                       /* nb_inplace_rshift */
2066         NULL,                       /* nb_inplace_and */
2067         NULL,                       /* nb_inplace_xor */
2068         NULL,                       /* nb_inplace_or */
2069         NULL,                       /* nb_floor_divide */
2070         Vector_div,                 /* nb_true_divide */
2071         NULL,                       /* nb_inplace_floor_divide */
2072         Vector_idiv,                /* nb_inplace_true_divide */
2073         NULL,                       /* nb_index */
2074 };
2075
2076 /*------------------PY_OBECT DEFINITION--------------------------*/
2077
2078 /* vector axis, vector.x/y/z/w */
2079
2080 PyDoc_STRVAR(Vector_axis_x_doc, "Vector X axis.\n\n:type: float");
2081 PyDoc_STRVAR(Vector_axis_y_doc, "Vector Y axis.\n\n:type: float");
2082 PyDoc_STRVAR(Vector_axis_z_doc, "Vector Z axis (3D Vectors only).\n\n:type: float");
2083 PyDoc_STRVAR(Vector_axis_w_doc, "Vector W axis (4D Vectors only).\n\n:type: float");
2084
2085 static PyObject *Vector_axis_get(VectorObject *self, void *type)
2086 {
2087         return vector_item_internal(self, GET_INT_FROM_POINTER(type), TRUE);
2088 }
2089
2090 static int Vector_axis_set(VectorObject *self, PyObject *value, void *type)
2091 {
2092         return vector_ass_item_internal(self, GET_INT_FROM_POINTER(type), value, TRUE);
2093 }
2094
2095 /* vector.length */
2096
2097 PyDoc_STRVAR(Vector_length_doc,
2098 "Vector Length.\n\n:type: float"
2099 );
2100 static PyObject *Vector_length_get(VectorObject *self, void *UNUSED(closure))
2101 {
2102         if (BaseMath_ReadCallback(self) == -1)
2103                 return NULL;
2104
2105         return PyFloat_FromDouble(sqrt(dot_vn_vn(self->vec, self->vec, self->size)));
2106 }
2107
2108 static int Vector_length_set(VectorObject *self, PyObject *value)
2109 {
2110         double dot = 0.0f, param;
2111
2112         if (BaseMath_ReadCallback(self) == -1)
2113                 return -1;
2114
2115         if ((param = PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) {
2116                 PyErr_SetString(PyExc_TypeError,
2117                                 "length must be set to a number");
2118                 return -1;
2119         }
2120
2121         if (param < 0.0) {
2122                 PyErr_SetString(PyExc_ValueError,
2123                                 "cannot set a vectors length to a negative value");
2124                 return -1;
2125         }
2126         if (param == 0.0) {
2127                 fill_vn_fl(self->vec, self->size, 0.0f);
2128                 return 0;
2129         }
2130
2131         dot = dot_vn_vn(self->vec, self->vec, self->size);
2132
2133         if (!dot) /* cant sqrt zero */
2134                 return 0;
2135
2136         dot = sqrt(dot);
2137
2138         if (dot == param)
2139                 return 0;
2140
2141         dot = dot / param;
2142
2143         mul_vn_fl(self->vec, self->size, 1.0 / dot);
2144
2145         (void)BaseMath_WriteCallback(self); /* checked already */
2146
2147         return 0;
2148 }
2149
2150 /* vector.length_squared */
2151 PyDoc_STRVAR(Vector_length_squared_doc,
2152 "Vector length squared (v.dot(v)).\n\n:type: float"
2153 );
2154 static PyObject *Vector_length_squared_get(VectorObject *self, void *UNUSED(closure))
2155 {
2156         if (BaseMath_ReadCallback(self) == -1)
2157                 return NULL;
2158
2159         return PyFloat_FromDouble(dot_vn_vn(self->vec, self->vec, self->size));
2160 }
2161
2162 /* Get a new Vector according to the provided swizzle. This function has little
2163  * error checking, as we are in control of the inputs: the closure is set by us
2164  * in Vector_createSwizzleGetSeter. */
2165 static PyObject *Vector_swizzle_get(VectorObject *self, void *closure)
2166 {
2167         size_t axis_to;
2168         size_t axis_from;
2169         float vec[MAX_DIMENSIONS];
2170         unsigned int swizzleClosure;
2171
2172         if (BaseMath_ReadCallback(self) == -1)
2173                 return NULL;
2174
2175         /* Unpack the axes from the closure into an array. */
2176         axis_to = 0;
2177         swizzleClosure = GET_INT_FROM_POINTER(closure);
2178         while (swizzleClosure & SWIZZLE_VALID_AXIS) {
2179                 axis_from = swizzleClosure & SWIZZLE_AXIS;
2180                 if (axis_from >= self->size) {
2181                         PyErr_SetString(PyExc_AttributeError,
2182                                         "Vector swizzle: "
2183                                         "specified axis not present");
2184                         return NULL;
2185                 }
2186
2187                 vec[axis_to] = self->vec[axis_from];
2188                 swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
2189                 axis_to++;
2190         }
2191
2192         return Vector_CreatePyObject(vec, axis_to, Py_NEW, Py_TYPE(self));
2193 }
2194
2195 /* Set the items of this vector using a swizzle.
2196  * - If value is a vector or list this operates like an array copy, except that
2197  *   the destination is effectively re-ordered as defined by the swizzle. At
2198  *   most min(len(source), len(dest)) values will be copied.
2199  * - If the value is scalar, it is copied to all axes listed in the swizzle.
2200  * - If an axis appears more than once in the swizzle, the final occurrence is
2201  *   the one that determines its value.
2202  *
2203  * Returns 0 on success and -1 on failure. On failure, the vector will be
2204  * unchanged. */
2205 static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure)
2206 {
2207         size_t size_from;
2208         float scalarVal;
2209
2210         size_t axis_from;
2211         size_t axis_to;
2212
2213         unsigned int swizzleClosure;
2214
2215         float tvec[MAX_DIMENSIONS];
2216         float vec_assign[MAX_DIMENSIONS];
2217
2218         if (BaseMath_ReadCallback(self) == -1)
2219                 return -1;
2220
2221         /* Check that the closure can be used with this vector: even 2D vectors have
2222          * swizzles defined for axes z and w, but they would be invalid. */
2223         swizzleClosure = GET_INT_FROM_POINTER(closure);
2224         axis_from = 0;
2225
2226         while (swizzleClosure & SWIZZLE_VALID_AXIS) {
2227                 axis_to = swizzleClosure & SWIZZLE_AXIS;
2228                 if (axis_to >= self->size) {
2229                         PyErr_SetString(PyExc_AttributeError,
2230                                         "Vector swizzle: "
2231                                         "specified axis not present");
2232                         return -1;
2233                 }
2234                 swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
2235                 axis_from++;
2236         }
2237
2238         if (((scalarVal = PyFloat_AsDouble(value)) == -1 && PyErr_Occurred()) == 0) {
2239                 int i;
2240
2241                 for (i = 0; i < MAX_DIMENSIONS; i++) {
2242                         vec_assign[i] = scalarVal;
2243                 }
2244
2245                 size_from = axis_from;
2246         }
2247         else if ((PyErr_Clear()), /* run but ignore the result */
2248                  (size_from = mathutils_array_parse(vec_assign, 2, 4, value,
2249                                                     "mathutils.Vector.**** = swizzle assignment")) == -1)
2250         {
2251                 return -1;
2252         }
2253
2254         if (axis_from != size_from) {
2255                 PyErr_SetString(PyExc_AttributeError,
2256                                 "Vector swizzle: size does not match swizzle");
2257                 return -1;
2258         }
2259
2260         /* Copy vector contents onto swizzled axes. */
2261         axis_from = 0;
2262         swizzleClosure = GET_INT_FROM_POINTER(closure);
2263
2264         while (swizzleClosure & SWIZZLE_VALID_AXIS) {
2265                 axis_to = swizzleClosure & SWIZZLE_AXIS;
2266                 tvec[axis_to] = vec_assign[axis_from];
2267                 swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
2268                 axis_from++;
2269         }
2270
2271         memcpy(self->vec, tvec, axis_from * sizeof(float));
2272         /* continue with BaseMathObject_WriteCallback at the end */
2273
2274         if (BaseMath_WriteCallback(self) == -1)
2275                 return -1;
2276         else
2277                 return 0;
2278 }
2279
2280 /*****************************************************************************/
2281 /* Python attributes get/set structure:                                      */
2282 /*****************************************************************************/
2283 static PyGetSetDef Vector_getseters[] = {
2284         {(char *)"x", (getter)Vector_axis_get, (setter)Vector_axis_set, Vector_axis_x_doc, (void *)0},
2285         {(char *)"y", (getter)Vector_axis_get, (setter)Vector_axis_set, Vector_axis_y_doc, (void *)1},
2286         {(char *)"z", (getter)Vector_axis_get, (setter)Vector_axis_set, Vector_axis_z_doc, (void *)2},
2287         {(char *)"w", (getter)Vector_axis_get, (setter)Vector_axis_set, Vector_axis_w_doc, (void *)3},
2288         {(char *)"length", (getter)Vector_length_get, (setter)Vector_length_set, Vector_length_doc, NULL},
2289         {(char *)"length_squared", (getter)Vector_length_squared_get, (setter)NULL, Vector_length_squared_doc, NULL},
2290         {(char *)"magnitude", (getter)Vector_length_get, (setter)Vector_length_set, Vector_length_doc, NULL},
2291         {(char *)"is_wrapped", (getter)BaseMathObject_is_wrapped_get, (setter)NULL, BaseMathObject_is_wrapped_doc, NULL},
2292         {(char *)"owner", (getter)BaseMathObject_owner_get, (setter)NULL, BaseMathObject_owner_doc, NULL},
2293
2294         /* autogenerated swizzle attrs, see python script below */
2295         {(char *)"xx",   (getter)Vector_swizzle_get, (setter)NULL, NULL, SET_INT_IN_POINTER(((0 | SWIZZLE_VALID_AXIS) | ((0 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 36
2296         {(char *)"xxx",  (getter)Vector_swizzle_get, (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
2297         {(char *)"xxxx", (getter)Vector_swizzle_get, (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
2298         {(char *)"xxxy", (getter)Vector_swizzle_get, (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
2299         {(char *)"xxxz", (getter)Vector_swizzle_get, (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
2300         {(char *)"xxxw", (getter)Vector_swizzle_get, (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
2301         {(char *)"xxy",  (getter)Vector_swizzle_get, (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
2302         {(char *)"xxyx", (getter)Vector_swizzle_get, (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
2303         {(char *)"xxyy", (getter)Vector_swizzle_get, (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
2304         {(char *)"xxyz", (getter)Vector_swizzle_get, (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
2305         {(char *)"xxyw", (getter)Vector_swizzle_get, (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
2306         {(char *)"xxz",  (getter)Vector_swizzle_get, (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
2307         {(char *)"xxzx", (getter)Vector_swizzle_get, (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
2308         {(char *)"xxzy", (getter)Vector_swizzle_get, (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
2309         {(char *)"xxzz", (getter)Vector_swizzle_get, (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
2310         {(char *)"xxzw", (getter)Vector_swizzle_get, (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
2311         {(char *)"xxw",  (getter)Vector_swizzle_get, (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
2312         {(char *)"xxwx", (getter)Vector_swizzle_get, (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
2313         {(char *)"xxwy", (getter)Vector_swizzle_get, (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
2314         {(char *)"xxwz", (getter)Vector_swizzle_get, (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
2315         {(char *)"xxww", (getter)Vector_swizzle_get, (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
2316         {(char *)"xy",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((0 | SWIZZLE_VALID_AXIS) | ((1 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 44
2317         {(char *)"xyx",  (getter)Vector_swizzle_get, (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
2318         {(char *)"xyxx", (getter)Vector_swizzle_get, (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
2319         {(char *)"xyxy", (getter)Vector_swizzle_get, (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
2320         {(char *)"xyxz", (getter)Vector_swizzle_get, (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
2321         {(char *)"xyxw", (getter)Vector_swizzle_get, (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
2322         {(char *)"xyy",  (getter)Vector_swizzle_get, (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
2323         {(char *)"xyyx", (getter)Vector_swizzle_get, (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
2324         {(char *)"xyyy", (getter)Vector_swizzle_get, (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
2325         {(char *)"xyyz", (getter)Vector_swizzle_get, (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
2326         {(char *)"xyyw", (getter)Vector_swizzle_get, (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
2327         {(char *)"xyz",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2328         {(char *)"xyzx", (getter)Vector_swizzle_get, (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
2329         {(char *)"xyzy", (getter)Vector_swizzle_get, (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
2330         {(char *)"xyzz", (getter)Vector_swizzle_get, (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
2331         {(char *)"xyzw", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2332         {(char *)"xyw",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2333         {(char *)"xywx", (getter)Vector_swizzle_get, (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
2334         {(char *)"xywy", (getter)Vector_swizzle_get, (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
2335         {(char *)"xywz", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2336         {(char *)"xyww", (getter)Vector_swizzle_get, (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
2337         {(char *)"xz",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((0 | SWIZZLE_VALID_AXIS) | ((2 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 52
2338         {(char *)"xzx",  (getter)Vector_swizzle_get, (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
2339         {(char *)"xzxx", (getter)Vector_swizzle_get, (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
2340         {(char *)"xzxy", (getter)Vector_swizzle_get, (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
2341         {(char *)"xzxz", (getter)Vector_swizzle_get, (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
2342         {(char *)"xzxw", (getter)Vector_swizzle_get, (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
2343         {(char *)"xzy",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2344         {(char *)"xzyx", (getter)Vector_swizzle_get, (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
2345         {(char *)"xzyy", (getter)Vector_swizzle_get, (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
2346         {(char *)"xzyz", (getter)Vector_swizzle_get, (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
2347         {(char *)"xzyw", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2348         {(char *)"xzz",  (getter)Vector_swizzle_get, (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
2349         {(char *)"xzzx", (getter)Vector_swizzle_get, (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
2350         {(char *)"xzzy", (getter)Vector_swizzle_get, (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
2351         {(char *)"xzzz", (getter)Vector_swizzle_get, (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
2352         {(char *)"xzzw", (getter)Vector_swizzle_get, (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
2353         {(char *)"xzw",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2354         {(char *)"xzwx", (getter)Vector_swizzle_get, (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
2355         {(char *)"xzwy", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2356         {(char *)"xzwz", (getter)Vector_swizzle_get, (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
2357         {(char *)"xzww", (getter)Vector_swizzle_get, (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
2358         {(char *)"xw",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((0 | SWIZZLE_VALID_AXIS) | ((3 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 60
2359         {(char *)"xwx",  (getter)Vector_swizzle_get, (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
2360         {(char *)"xwxx", (getter)Vector_swizzle_get, (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
2361         {(char *)"xwxy", (getter)Vector_swizzle_get, (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
2362         {(char *)"xwxz", (getter)Vector_swizzle_get, (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
2363         {(char *)"xwxw", (getter)Vector_swizzle_get, (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
2364         {(char *)"xwy",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2365         {(char *)"xwyx", (getter)Vector_swizzle_get, (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
2366         {(char *)"xwyy", (getter)Vector_swizzle_get, (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
2367         {(char *)"xwyz", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2368         {(char *)"xwyw", (getter)Vector_swizzle_get, (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
2369         {(char *)"xwz",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2370         {(char *)"xwzx", (getter)Vector_swizzle_get, (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
2371         {(char *)"xwzy", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2372         {(char *)"xwzz", (getter)Vector_swizzle_get, (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
2373         {(char *)"xwzw", (getter)Vector_swizzle_get, (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
2374         {(char *)"xww",  (getter)Vector_swizzle_get, (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
2375         {(char *)"xwwx", (getter)Vector_swizzle_get, (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
2376         {(char *)"xwwy", (getter)Vector_swizzle_get, (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
2377         {(char *)"xwwz", (getter)Vector_swizzle_get, (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
2378         {(char *)"xwww", (getter)Vector_swizzle_get, (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
2379         {(char *)"yx",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((1 | SWIZZLE_VALID_AXIS) | ((0 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 37
2380         {(char *)"yxx",  (getter)Vector_swizzle_get, (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
2381         {(char *)"yxxx", (getter)Vector_swizzle_get, (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
2382         {(char *)"yxxy", (getter)Vector_swizzle_get, (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
2383         {(char *)"yxxz", (getter)Vector_swizzle_get, (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
2384         {(char *)"yxxw", (getter)Vector_swizzle_get, (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
2385         {(char *)"yxy",  (getter)Vector_swizzle_get, (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
2386         {(char *)"yxyx", (getter)Vector_swizzle_get, (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
2387         {(char *)"yxyy", (getter)Vector_swizzle_get, (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
2388         {(char *)"yxyz", (getter)Vector_swizzle_get, (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
2389         {(char *)"yxyw", (getter)Vector_swizzle_get, (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
2390         {(char *)"yxz",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2391         {(char *)"yxzx", (getter)Vector_swizzle_get, (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
2392         {(char *)"yxzy", (getter)Vector_swizzle_get, (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
2393         {(char *)"yxzz", (getter)Vector_swizzle_get, (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
2394         {(char *)"yxzw", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2395         {(char *)"yxw",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2396         {(char *)"yxwx", (getter)Vector_swizzle_get, (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
2397         {(char *)"yxwy", (getter)Vector_swizzle_get, (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
2398         {(char *)"yxwz", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2399         {(char *)"yxww", (getter)Vector_swizzle_get, (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
2400         {(char *)"yy",   (getter)Vector_swizzle_get, (setter)NULL, NULL, SET_INT_IN_POINTER(((1 | SWIZZLE_VALID_AXIS) | ((1 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 45
2401         {(char *)"yyx",  (getter)Vector_swizzle_get, (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
2402         {(char *)"yyxx", (getter)Vector_swizzle_get, (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
2403         {(char *)"yyxy", (getter)Vector_swizzle_get, (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
2404         {(char *)"yyxz", (getter)Vector_swizzle_get, (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
2405         {(char *)"yyxw", (getter)Vector_swizzle_get, (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
2406         {(char *)"yyy",  (getter)Vector_swizzle_get, (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
2407         {(char *)"yyyx", (getter)Vector_swizzle_get, (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
2408         {(char *)"yyyy", (getter)Vector_swizzle_get, (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
2409         {(char *)"yyyz", (getter)Vector_swizzle_get, (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
2410         {(char *)"yyyw", (getter)Vector_swizzle_get, (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
2411         {(char *)"yyz",  (getter)Vector_swizzle_get, (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
2412         {(char *)"yyzx", (getter)Vector_swizzle_get, (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
2413         {(char *)"yyzy", (getter)Vector_swizzle_get, (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
2414         {(char *)"yyzz", (getter)Vector_swizzle_get, (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
2415         {(char *)"yyzw", (getter)Vector_swizzle_get, (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
2416         {(char *)"yyw",  (getter)Vector_swizzle_get, (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
2417         {(char *)"yywx", (getter)Vector_swizzle_get, (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
2418         {(char *)"yywy", (getter)Vector_swizzle_get, (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
2419         {(char *)"yywz", (getter)Vector_swizzle_get, (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
2420         {(char *)"yyww", (getter)Vector_swizzle_get, (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
2421         {(char *)"yz",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((1 | SWIZZLE_VALID_AXIS) | ((2 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 53
2422         {(char *)"yzx",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2423         {(char *)"yzxx", (getter)Vector_swizzle_get, (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
2424         {(char *)"yzxy", (getter)Vector_swizzle_get, (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
2425         {(char *)"yzxz", (getter)Vector_swizzle_get, (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
2426         {(char *)"yzxw", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2427         {(char *)"yzy",  (getter)Vector_swizzle_get, (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
2428         {(char *)"yzyx", (getter)Vector_swizzle_get, (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
2429         {(char *)"yzyy", (getter)Vector_swizzle_get, (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
2430         {(char *)"yzyz", (getter)Vector_swizzle_get, (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
2431         {(char *)"yzyw", (getter)Vector_swizzle_get, (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
2432         {(char *)"yzz",  (getter)Vector_swizzle_get, (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
2433         {(char *)"yzzx", (getter)Vector_swizzle_get, (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
2434         {(char *)"yzzy", (getter)Vector_swizzle_get, (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
2435         {(char *)"yzzz", (getter)Vector_swizzle_get, (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
2436         {(char *)"yzzw", (getter)Vector_swizzle_get, (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
2437         {(char *)"yzw",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2438         {(char *)"yzwx", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2439         {(char *)"yzwy", (getter)Vector_swizzle_get, (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
2440         {(char *)"yzwz", (getter)Vector_swizzle_get, (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
2441         {(char *)"yzww", (getter)Vector_swizzle_get, (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
2442         {(char *)"yw",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((1 | SWIZZLE_VALID_AXIS) | ((3 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 61
2443         {(char *)"ywx",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2444         {(char *)"ywxx", (getter)Vector_swizzle_get, (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
2445         {(char *)"ywxy", (getter)Vector_swizzle_get, (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
2446         {(char *)"ywxz", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2447         {(char *)"ywxw", (getter)Vector_swizzle_get, (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
2448         {(char *)"ywy",  (getter)Vector_swizzle_get, (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
2449         {(char *)"ywyx", (getter)Vector_swizzle_get, (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
2450         {(char *)"ywyy", (getter)Vector_swizzle_get, (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
2451         {(char *)"ywyz", (getter)Vector_swizzle_get, (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
2452         {(char *)"ywyw", (getter)Vector_swizzle_get, (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
2453         {(char *)"ywz",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2454         {(char *)"ywzx", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2455         {(char *)"ywzy", (getter)Vector_swizzle_get, (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
2456         {(char *)"ywzz", (getter)Vector_swizzle_get, (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
2457         {(char *)"ywzw", (getter)Vector_swizzle_get, (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
2458         {(char *)"yww",  (getter)Vector_swizzle_get, (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
2459         {(char *)"ywwx", (getter)Vector_swizzle_get, (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
2460         {(char *)"ywwy", (getter)Vector_swizzle_get, (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
2461         {(char *)"ywwz", (getter)Vector_swizzle_get, (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
2462         {(char *)"ywww", (getter)Vector_swizzle_get, (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
2463         {(char *)"zx",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((2 | SWIZZLE_VALID_AXIS) | ((0 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 38
2464         {(char *)"zxx",  (getter)Vector_swizzle_get, (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
2465         {(char *)"zxxx", (getter)Vector_swizzle_get, (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
2466         {(char *)"zxxy", (getter)Vector_swizzle_get, (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
2467         {(char *)"zxxz", (getter)Vector_swizzle_get, (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
2468         {(char *)"zxxw", (getter)Vector_swizzle_get, (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
2469         {(char *)"zxy",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2470         {(char *)"zxyx", (getter)Vector_swizzle_get, (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
2471         {(char *)"zxyy", (getter)Vector_swizzle_get, (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
2472         {(char *)"zxyz", (getter)Vector_swizzle_get, (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
2473         {(char *)"zxyw", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2474         {(char *)"zxz",  (getter)Vector_swizzle_get, (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
2475         {(char *)"zxzx", (getter)Vector_swizzle_get, (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
2476         {(char *)"zxzy", (getter)Vector_swizzle_get, (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
2477         {(char *)"zxzz", (getter)Vector_swizzle_get, (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
2478         {(char *)"zxzw", (getter)Vector_swizzle_get, (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
2479         {(char *)"zxw",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2480         {(char *)"zxwx", (getter)Vector_swizzle_get, (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
2481         {(char *)"zxwy", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2482         {(char *)"zxwz", (getter)Vector_swizzle_get, (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
2483         {(char *)"zxww", (getter)Vector_swizzle_get, (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
2484         {(char *)"zy",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((2 | SWIZZLE_VALID_AXIS) | ((1 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 46
2485         {(char *)"zyx",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2486         {(char *)"zyxx", (getter)Vector_swizzle_get, (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
2487         {(char *)"zyxy", (getter)Vector_swizzle_get, (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
2488         {(char *)"zyxz", (getter)Vector_swizzle_get, (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
2489         {(char *)"zyxw", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2490         {(char *)"zyy",  (getter)Vector_swizzle_get, (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
2491         {(char *)"zyyx", (getter)Vector_swizzle_get, (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
2492         {(char *)"zyyy", (getter)Vector_swizzle_get, (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
2493         {(char *)"zyyz", (getter)Vector_swizzle_get, (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
2494         {(char *)"zyyw", (getter)Vector_swizzle_get, (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
2495         {(char *)"zyz",  (getter)Vector_swizzle_get, (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
2496         {(char *)"zyzx", (getter)Vector_swizzle_get, (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
2497         {(char *)"zyzy", (getter)Vector_swizzle_get, (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
2498         {(char *)"zyzz", (getter)Vector_swizzle_get, (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
2499         {(char *)"zyzw", (getter)Vector_swizzle_get, (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
2500         {(char *)"zyw",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2501         {(char *)"zywx", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2502         {(char *)"zywy", (getter)Vector_swizzle_get, (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
2503         {(char *)"zywz", (getter)Vector_swizzle_get, (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
2504         {(char *)"zyww", (getter)Vector_swizzle_get, (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
2505         {(char *)"zz",   (getter)Vector_swizzle_get, (setter)NULL, NULL, SET_INT_IN_POINTER(((2 | SWIZZLE_VALID_AXIS) | ((2 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 54
2506         {(char *)"zzx",  (getter)Vector_swizzle_get, (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
2507         {(char *)"zzxx", (getter)Vector_swizzle_get, (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
2508         {(char *)"zzxy", (getter)Vector_swizzle_get, (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
2509         {(char *)"zzxz", (getter)Vector_swizzle_get, (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
2510         {(char *)"zzxw", (getter)Vector_swizzle_get, (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
2511         {(char *)"zzy",  (getter)Vector_swizzle_get, (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
2512         {(char *)"zzyx", (getter)Vector_swizzle_get, (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
2513         {(char *)"zzyy", (getter)Vector_swizzle_get, (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
2514         {(char *)"zzyz", (getter)Vector_swizzle_get, (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
2515         {(char *)"zzyw", (getter)Vector_swizzle_get, (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
2516         {(char *)"zzz",  (getter)Vector_swizzle_get, (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
2517         {(char *)"zzzx", (getter)Vector_swizzle_get, (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
2518         {(char *)"zzzy", (getter)Vector_swizzle_get, (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
2519         {(char *)"zzzz", (getter)Vector_swizzle_get, (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
2520         {(char *)"zzzw", (getter)Vector_swizzle_get, (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
2521         {(char *)"zzw",  (getter)Vector_swizzle_get, (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
2522         {(char *)"zzwx", (getter)Vector_swizzle_get, (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
2523         {(char *)"zzwy", (getter)Vector_swizzle_get, (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
2524         {(char *)"zzwz", (getter)Vector_swizzle_get, (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
2525         {(char *)"zzww", (getter)Vector_swizzle_get, (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
2526         {(char *)"zw",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((2 | SWIZZLE_VALID_AXIS) | ((3 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 62
2527         {(char *)"zwx",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2528         {(char *)"zwxx", (getter)Vector_swizzle_get, (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
2529         {(char *)"zwxy", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2530         {(char *)"zwxz", (getter)Vector_swizzle_get, (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
2531         {(char *)"zwxw", (getter)Vector_swizzle_get, (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
2532         {(char *)"zwy",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2533         {(char *)"zwyx", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2534         {(char *)"zwyy", (getter)Vector_swizzle_get, (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
2535         {(char *)"zwyz", (getter)Vector_swizzle_get, (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
2536         {(char *)"zwyw", (getter)Vector_swizzle_get, (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
2537         {(char *)"zwz",  (getter)Vector_swizzle_get, (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
2538         {(char *)"zwzx", (getter)Vector_swizzle_get, (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
2539         {(char *)"zwzy", (getter)Vector_swizzle_get, (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
2540         {(char *)"zwzz", (getter)Vector_swizzle_get, (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
2541         {(char *)"zwzw", (getter)Vector_swizzle_get, (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
2542         {(char *)"zww",  (getter)Vector_swizzle_get, (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
2543         {(char *)"zwwx", (getter)Vector_swizzle_get, (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
2544         {(char *)"zwwy", (getter)Vector_swizzle_get, (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
2545         {(char *)"zwwz", (getter)Vector_swizzle_get, (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
2546         {(char *)"zwww", (getter)Vector_swizzle_get, (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
2547         {(char *)"wx",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((3 | SWIZZLE_VALID_AXIS) | ((0 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 39
2548         {(char *)"wxx",  (getter)Vector_swizzle_get, (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
2549         {(char *)"wxxx", (getter)Vector_swizzle_get, (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
2550         {(char *)"wxxy", (getter)Vector_swizzle_get, (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
2551         {(char *)"wxxz", (getter)Vector_swizzle_get, (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
2552         {(char *)"wxxw", (getter)Vector_swizzle_get, (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
2553         {(char *)"wxy",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2554         {(char *)"wxyx", (getter)Vector_swizzle_get, (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
2555         {(char *)"wxyy", (getter)Vector_swizzle_get, (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
2556         {(char *)"wxyz", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2557         {(char *)"wxyw", (getter)Vector_swizzle_get, (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
2558         {(char *)"wxz",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2559         {(char *)"wxzx", (getter)Vector_swizzle_get, (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
2560         {(char *)"wxzy", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2561         {(char *)"wxzz", (getter)Vector_swizzle_get, (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
2562         {(char *)"wxzw", (getter)Vector_swizzle_get, (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
2563         {(char *)"wxw",  (getter)Vector_swizzle_get, (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
2564         {(char *)"wxwx", (getter)Vector_swizzle_get, (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
2565         {(char *)"wxwy", (getter)Vector_swizzle_get, (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
2566         {(char *)"wxwz", (getter)Vector_swizzle_get, (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
2567         {(char *)"wxww", (getter)Vector_swizzle_get, (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
2568         {(char *)"wy",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((3 | SWIZZLE_VALID_AXIS) | ((1 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 47
2569         {(char *)"wyx",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2570         {(char *)"wyxx", (getter)Vector_swizzle_get, (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
2571         {(char *)"wyxy", (getter)Vector_swizzle_get, (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
2572         {(char *)"wyxz", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2573         {(char *)"wyxw", (getter)Vector_swizzle_get, (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
2574         {(char *)"wyy",  (getter)Vector_swizzle_get, (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
2575         {(char *)"wyyx", (getter)Vector_swizzle_get, (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
2576         {(char *)"wyyy", (getter)Vector_swizzle_get, (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
2577         {(char *)"wyyz", (getter)Vector_swizzle_get, (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
2578         {(char *)"wyyw", (getter)Vector_swizzle_get, (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
2579         {(char *)"wyz",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2580         {(char *)"wyzx", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2581         {(char *)"wyzy", (getter)Vector_swizzle_get, (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
2582         {(char *)"wyzz", (getter)Vector_swizzle_get, (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
2583         {(char *)"wyzw", (getter)Vector_swizzle_get, (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
2584         {(char *)"wyw",  (getter)Vector_swizzle_get, (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
2585         {(char *)"wywx", (getter)Vector_swizzle_get, (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
2586         {(char *)"wywy", (getter)Vector_swizzle_get, (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
2587         {(char *)"wywz", (getter)Vector_swizzle_get, (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
2588         {(char *)"wyww", (getter)Vector_swizzle_get, (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
2589         {(char *)"wz",   (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, NULL, SET_INT_IN_POINTER(((3 | SWIZZLE_VALID_AXIS) | ((2 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 55
2590         {(char *)"wzx",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2591         {(char *)"wzxx", (getter)Vector_swizzle_get, (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
2592         {(char *)"wzxy", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2593         {(char *)"wzxz", (getter)Vector_swizzle_get, (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
2594         {(char *)"wzxw", (getter)Vector_swizzle_get, (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
2595         {(char *)"wzy",  (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2596         {(char *)"wzyx", (getter)Vector_swizzle_get, (setter)Vector_swizzle_set, 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
2597         {(char *)"wzyy", (getter)Vector_swizzle_get, (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
2598         {(char *)"wzyz", (getter)Vector_swizzle_get, (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
2599         {(char *)"wzyw", (getter)Vector_swizzle_get, (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
2600         {(char *)"wzz",  (getter)Vector_swizzle_get, (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
2601         {(char *)"wzzx", (getter)Vector_swizzle_get, (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
2602         {(char *)"wzzy", (getter)Vector_swizzle_get, (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
2603         {(char *)"wzzz", (getter)Vector_swizzle_get, (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
2604         {(char *)"wzzw", (getter)Vector_swizzle_get, (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
2605         {(char *)"wzw",  (getter)Vector_swizzle_get, (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
2606         {(char *)"wzwx", (getter)Vector_swizzle_get, (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
2607         {(char *)"wzwy", (getter)Vector_swizzle_get, (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
2608         {(char *)"wzwz", (getter)Vector_swizzle_get, (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
2609         {(char *)"wzww", (getter)Vector_swizzle_get, (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
2610         {(char *)"ww",   (getter)Vector_swizzle_get, (setter)NULL, NULL, SET_INT_IN_POINTER(((3 | SWIZZLE_VALID_AXIS) | ((3 | SWIZZLE_VALID_AXIS) << SWIZZLE_BITS_PER_AXIS)))}, // 63
2611         {(char *)"wwx",  (getter)Vector_swizzle_get, (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
2612         {(char *)"wwxx", (getter)Vector_swizzle_get, (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
2613         {(char *)"wwxy", (getter)Vector_swizzle_get, (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
2614         {(char *)"wwxz", (getter)Vector_swizzle_get, (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
2615         {(char *)"wwxw", (getter)Vector_swizzle_get, (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
2616         {(char *)"wwy",  (getter)Vector_swizzle_get, (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
2617         {(char *)"wwyx", (getter)Vector_swizzle_get, (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
2618         {(char *)"wwyy", (getter)Vector_swizzle_get, (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
2619         {(char *)"wwyz", (getter)Vector_swizzle_get, (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
2620         {(char *)"wwyw", (getter)Vector_swizzle_get, (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
2621         {(char *)"wwz",  (getter)Vector_swizzle_get, (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
2622         {(char *)"wwzx", (getter)Vector_swizzle_get, (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
2623         {(char *)"wwzy", (getter)Vector_swizzle_get, (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
2624         {(char *)"wwzz", (getter)Vector_swizzle_get, (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
2625         {(char *)"wwzw", (getter)Vector_swizzle_get, (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
2626         {(char *)"www",  (getter)Vector_swizzle_get, (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
2627         {(char *)"wwwx", (getter)Vector_swizzle_get, (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
2628         {(char *)"wwwy", (getter)Vector_swizzle_get, (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
2629         {(char *)"wwwz", (getter)Vector_swizzle_get, (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
2630         {(char *)"wwww", (getter)Vector_swizzle_get, (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
2631         {NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
2632 };
2633
2634 /* Python script used to make swizzle array */
2635 /*
2636 SWIZZLE_BITS_PER_AXIS = 3
2637 SWIZZLE_VALID_AXIS = 0x4
2638
2639 axis_dict = {}
2640 axis_pos = {'x':0, 'y':1, 'z':2, 'w':3}
2641 axises = 'xyzw'
2642 while len(axises) >= 2:
2643
2644         for axis_0 in axises:
2645                 axis_0_pos = axis_pos[axis_0]
2646                 for axis_1 in axises:
2647                         axis_1_pos = axis_pos[axis_1]
2648                         axis_dict[axis_0 + axis_1] = '((%s|SWIZZLE_VALID_AXIS) | ((%s|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS))' % (axis_0_pos, axis_1_pos)
2649                         if len(axises)>2:
2650                                 for axis_2 in axises:
2651                                         axis_2_pos = axis_pos[axis_2]
2652                                         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)
2653                                         if len(axises)>3:
2654                                                 for axis_3 in axises:
2655                                                         axis_3_pos = axis_pos[axis_3]
2656                                                         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)
2657
2658         axises = axises[:-1]
2659
2660
2661 items = axis_dict.items()
2662 items.sort(key = lambda a: a[0].replace('x', '0').replace('y', '1').replace('z', '2').replace('w', '3'))
2663
2664 unique = set()
2665 for key, val in items:
2666         num = eval(val)
2667         set_str = 'Vector_setSwizzle' if (len(set(key)) == len(key)) else 'NULL'
2668         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)
2669         unique.add(num)
2670
2671 if len(unique) != len(items):
2672         print "ERROR"
2673 */
2674
2675 /* ROW VECTOR Multiplication - Vector X Matrix
2676  * [x][y][z] * [1][4][7]
2677  *             [2][5][8]
2678  *             [3][6][9]
2679  * vector/matrix multiplication IS NOT COMMUTATIVE!!!! */
2680 static int row_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject *vec, MatrixObject *mat)
2681 {
2682         float vec_cpy[MAX_DIMENSIONS];
2683         int row, col, z = 0, vec_size = vec->size;
2684
2685         if (mat->num_row != vec_size) {
2686                 if (mat->num_row == 4 && vec_size == 3) {
2687                         vec_cpy[3] = 1.0f;
2688                 }
2689                 else {
2690                         PyErr_SetString(PyExc_ValueError,
2691                                         "vector * matrix: matrix column size "
2692                                         "and the vector size must be the same");
2693                         return -1;
2694                 }
2695         }
2696
2697         if (BaseMath_ReadCallback(vec) == -1 || BaseMath_ReadCallback(mat) == -1)
2698                 return -1;
2699
2700         memcpy(vec_cpy, vec->vec, vec_size * sizeof(float));
2701
2702         r_vec[3] = 1.0f;
2703         //muliplication
2704         for (col = 0; col < mat->num_col; col++) {
2705                 double dot = 0.0;
2706                 for (row = 0; row < mat->num_row; row++) {
2707                         dot += MATRIX_ITEM(mat, row, col) * vec_cpy[row];
2708                 }
2709                 r_vec[z++] = (float)dot;
2710         }
2711         return 0;
2712 }
2713
2714 /*----------------------------Vector.negate() -------------------- */
2715 PyDoc_STRVAR(Vector_negate_doc,
2716 ".. method:: negate()\n"
2717 "\n"
2718 "   Set all values to their negative.\n"
2719 );
2720 static PyObject *Vector_negate(VectorObject *self)
2721 {
2722         if (BaseMath_ReadCallback(self) == -1)
2723                 return NULL;
2724
2725         negate_vn(self->vec, self->size);
2726
2727         (void)BaseMath_WriteCallback(self); // already checked for error
2728         Py_RETURN_NONE;
2729 }
2730
2731 static struct PyMethodDef Vector_methods[] = {
2732         /* Class Methods */
2733         {"Fill", (PyCFunction) C_Vector_Fill, METH_VARARGS | METH_CLASS, C_Vector_Fill_doc},
2734         {"Range", (PyCFunction) C_Vector_Range, METH_VARARGS | METH_CLASS, C_Vector_Range_doc},
2735         {"Linspace", (PyCFunction) C_Vector_Linspace, METH_VARARGS | METH_CLASS, C_Vector_Linspace_doc},
2736         {"Repeat", (PyCFunction) C_Vector_Repeat, METH_VARARGS | METH_CLASS, C_Vector_Repeat_doc},
2737
2738         /* in place only */
2739         {"zero", (PyCFunction) Vector_zero, METH_NOARGS, Vector_zero_doc},
2740         {"negate", (PyCFunction) Vector_negate, METH_NOARGS, Vector_negate_doc},
2741
2742         /* operate on original or copy */
2743         {"normalize", (PyCFunction) Vector_normalize, METH_NOARGS, Vector_normalize_doc},
2744         {"normalized", (PyCFunction) Vector_normalized, METH_NOARGS, Vector_normalized_doc},
2745
2746         {"resize", (PyCFunction) Vector_resize, METH_O, Vector_resize_doc},
2747         {"resized", (PyCFunction) Vector_resized, METH_O, Vector_resized_doc},
2748         {"to_2d", (PyCFunction) Vector_to_2d, METH_NOARGS, Vector_to_2d_doc},
2749         {"resize_2d", (PyCFunction) Vector_resize_2d, METH_NOARGS, Vector_resize_2d_doc},
2750         {"to_3d", (PyCFunction) Vector_to_3d, METH_NOARGS, Vector_to_3d_doc},
2751         {"resize_3d", (PyCFunction) Vector_resize_3d, METH_NOARGS, Vector_resize_3d_doc},
2752         {"to_4d", (PyCFunction) Vector_to_4d, METH_NOARGS, Vector_to_4d_doc},
2753         {"resize_4d", (PyCFunction) Vector_resize_4d, METH_NOARGS, Vector_resize_4d_doc},
2754         {"to_tuple", (PyCFunction) Vector_to_tuple, METH_VARARGS, Vector_to_tuple_doc},
2755         {"to_track_quat", (PyCFunction) Vector_to_track_quat, METH_VARARGS, Vector_to_track_quat_doc},
2756
2757         /* operation between 2 or more types  */
2758         {"reflect", (PyCFunction) Vector_reflect, METH_O, Vector_reflect_doc},
2759         {"cross", (PyCFunction) Vector_cross, METH_O, Vector_cross_doc},
2760         {"dot", (PyCFunction) Vector_dot, METH_O, Vector_dot_doc},
2761         {"angle", (PyCFunction) Vector_angle, METH_VARARGS, Vector_angle_doc},
2762         {"angle_signed", (PyCFunction) Vector_angle_signed, METH_VARARGS, Vector_angle_signed_doc},
2763         {"rotation_difference", (PyCFunction) Vector_rotation_difference, METH_O, Vector_rotation_difference_doc},
2764         {"project", (PyCFunction) Vector_project, METH_O, Vector_project_doc},
2765         {"lerp", (PyCFunction) Vector_lerp, METH_VARARGS, Vector_lerp_doc},
2766         {"rotate", (PyCFunction) Vector_rotate, METH_O, Vector_rotate_doc},
2767
2768         {"copy", (PyCFunction) Vector_copy, METH_NOARGS, Vector_copy_doc},
2769         {"__copy__", (PyCFunction) Vector_copy, METH_NOARGS, NULL},
2770         {NULL, NULL, 0, NULL}
2771 };
2772
2773
2774 /* Note
2775  * Py_TPFLAGS_CHECKTYPES allows us to avoid casting all types to Vector when coercing
2776  * but this means for eg that
2777  * (vec * mat) and (mat * vec) both get sent to Vector_mul and it neesd to sort out the order
2778  */
2779
2780 PyDoc_STRVAR(vector_doc,
2781 "This object gives access to Vectors in Blender."
2782 );
2783 PyTypeObject vector_Type = {
2784         PyVarObject_HEAD_INIT(NULL, 0)
2785         /*  For printing, in format "<module>.<name>" */
2786         "mathutils.Vector",             /* char *tp_name; */
2787         sizeof(VectorObject),         /* int tp_basicsize; */
2788         0,                          /* tp_itemsize;  For allocation */
2789
2790         /* Methods to implement standard operations */
2791
2792         (destructor) BaseMathObject_dealloc, /* destructor tp_dealloc; */
2793         NULL,                       /* printfunc tp_print; */
2794         NULL,                       /* getattrfunc tp_getattr; */
2795         NULL,                       /* setattrfunc tp_setattr; */
2796         NULL,   /* cmpfunc tp_compare; */
2797         (reprfunc)Vector_repr,     /* reprfunc tp_repr; */
2798
2799         /* Method suites for&n