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