← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/python/generic/mathutils_vector.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2012-07-23 08:54:18 UTC
  • mfrom: (14.2.16 sid)
  • mto: (14.2.19 sid)
  • mto: This revision was merged to the branch mainline in revision 42.
  • Revision ID: package-import@ubuntu.com-20120723085418-9foz30v6afaf5ffs
Tags: 2.63a-2
http://bugs.debian.org/658075
* debian/: Cycles support added (Closes: #658075)
  For now, this top feature has been enabled only
  on [any-amd64 any-i386] architectures because
  of OpenImageIO failing on all others
* debian/: scripts installation path changed
  from /usr/lib to /usr/share:
  + debian/patches/: patchset re-worked for path changing
  + debian/control: "Breaks" field added on yafaray-exporter

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/python/generic/mathutils_vector.c
1
 
/*
2
 
 * $Id: mathutils_vector.c 30446 2010-07-17 18:08:14Z campbellbarton $
3
 
 * ***** BEGIN GPL LICENSE BLOCK *****
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or
6
 
 * modify it under the terms of the GNU General Public License
7
 
 * as published by the Free Software Foundation; either version 2
8
 
 * of the License, or (at your option) any later version.
9
 
 *
10
 
 * This program is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program; if not, write to the Free Software Foundation,
17
 
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18
 
 *
19
 
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20
 
 * All rights reserved.
21
 
 *
22
 
 * 
23
 
 * Contributor(s): Willian P. Germano, Joseph Gilbert, Ken Hughes, Alex Fraser, Campbell Barton
24
 
 *
25
 
 * ***** END GPL LICENSE BLOCK *****
26
 
 */
27
 
 
28
 
#include "mathutils.h"
29
 
 
30
 
#include "BLI_blenlib.h"
31
 
#include "BKE_utildefines.h"
32
 
#include "BLI_math.h"
33
 
 
34
 
#define MAX_DIMENSIONS 4
35
 
/* Swizzle axes get packed into a single value that is used as a closure. Each
36
 
   axis uses SWIZZLE_BITS_PER_AXIS bits. The first bit (SWIZZLE_VALID_AXIS) is
37
 
   used as a sentinel: if it is unset, the axis is not valid. */
38
 
#define SWIZZLE_BITS_PER_AXIS 3
39
 
#define SWIZZLE_VALID_AXIS 0x4
40
 
#define SWIZZLE_AXIS       0x3
41
 
 
42
 
static PyObject *row_vector_multiplication(VectorObject* vec, MatrixObject * mat); /* utility func */
43
 
static PyObject *Vector_ToTupleExt(VectorObject *self, int ndigits);
44
 
 
45
 
//----------------------------------mathutils.Vector() ------------------
46
 
// Supports 2D, 3D, and 4D vector objects both int and float values
47
 
// accepted. Mixed float and int values accepted. Ints are parsed to float 
48
 
static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
49
 
{
50
 
        float vec[4]= {0.0f, 0.0f, 0.0f, 0.0f};
51
 
        int size= 3; /* default to a 3D vector */
52
 
 
53
 
        switch(PyTuple_GET_SIZE(args)) {
54
 
        case 0:
55
 
                break;
56
 
        case 1:
57
 
                if((size=mathutils_array_parse(vec, 2, 4, PyTuple_GET_ITEM(args, 0), "mathutils.Vector()")) == -1)
58
 
                        return NULL;
59
 
                break;
60
 
        default:
61
 
                PyErr_SetString(PyExc_TypeError, "mathutils.Vector(): more then a single arg given");
62
 
                return NULL;
63
 
        }
64
 
        return newVectorObject(vec, size, Py_NEW, type);
65
 
}
66
 
 
67
 
/*-----------------------------METHODS---------------------------- */
68
 
static char Vector_Zero_doc[] =
69
 
".. method:: zero()\n"
70
 
"\n"
71
 
"   Set all values to zero.\n"
72
 
"\n"
73
 
"   :return: an instance of itself\n"
74
 
"   :rtype: :class:`Vector`\n";
75
 
 
76
 
static PyObject *Vector_Zero(VectorObject *self)
77
 
{
78
 
        int i;
79
 
        for(i = 0; i < self->size; i++) {
80
 
                self->vec[i] = 0.0f;
81
 
        }
82
 
        
83
 
        BaseMath_WriteCallback(self);
84
 
        Py_INCREF(self);
85
 
        return (PyObject*)self;
86
 
}
87
 
/*----------------------------Vector.normalize() ----------------- */
88
 
static char Vector_Normalize_doc[] =
89
 
".. method:: normalize()\n"
90
 
"\n"
91
 
"   Normalize the vector, making the length of the vector always 1.0.\n"
92
 
"\n"
93
 
"   :return: an instance of itself\n"
94
 
"   :rtype: :class:`Vector`\n"
95
 
"\n"
96
 
"   .. warning:: Normalizing a vector where all values are zero results in all axis having a nan value (not a number).\n"
97
 
"\n"
98
 
"   .. note:: Normalize works for vectors of all sizes, however 4D Vectors w axis is left untouched.\n";
99
 
 
100
 
static PyObject *Vector_Normalize(VectorObject *self)
101
 
{
102
 
        int i;
103
 
        float norm = 0.0f;
104
 
 
105
 
        if(!BaseMath_ReadCallback(self))
106
 
                return NULL;
107
 
        
108
 
        for(i = 0; i < self->size; i++) {
109
 
                norm += self->vec[i] * self->vec[i];
110
 
        }
111
 
        norm = (float) sqrt(norm);
112
 
        for(i = 0; i < self->size; i++) {
113
 
                self->vec[i] /= norm;
114
 
        }
115
 
        
116
 
        BaseMath_WriteCallback(self);
117
 
        Py_INCREF(self);
118
 
        return (PyObject*)self;
119
 
}
120
 
 
121
 
 
122
 
/*----------------------------Vector.resize2D() ------------------ */
123
 
static char Vector_Resize2D_doc[] =
124
 
".. method:: resize2D()\n"
125
 
"\n"
126
 
"   Resize the vector to 2D  (x, y).\n"
127
 
"\n"
128
 
"   :return: an instance of itself\n"
129
 
"   :rtype: :class:`Vector`\n";
130
 
 
131
 
static PyObject *Vector_Resize2D(VectorObject *self)
132
 
{
133
 
        if(self->wrapped==Py_WRAP) {
134
 
                PyErr_SetString(PyExc_TypeError, "vector.resize2D(): cannot resize wrapped data - only python vectors\n");
135
 
                return NULL;
136
 
        }
137
 
        if(self->cb_user) {
138
 
                PyErr_SetString(PyExc_TypeError, "vector.resize2D(): cannot resize a vector that has an owner");
139
 
                return NULL;
140
 
        }
141
 
        
142
 
        self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 2));
143
 
        if(self->vec == NULL) {
144
 
                PyErr_SetString(PyExc_MemoryError, "vector.resize2D(): problem allocating pointer space\n\n");
145
 
                return NULL;
146
 
        }
147
 
        
148
 
        self->size = 2;
149
 
        Py_INCREF(self);
150
 
        return (PyObject*)self;
151
 
}
152
 
/*----------------------------Vector.resize3D() ------------------ */
153
 
static char Vector_Resize3D_doc[] =
154
 
".. method:: resize3D()\n"
155
 
"\n"
156
 
"   Resize the vector to 3D  (x, y, z).\n"
157
 
"\n"
158
 
"   :return: an instance of itself\n"
159
 
"   :rtype: :class:`Vector`\n";
160
 
 
161
 
static PyObject *Vector_Resize3D(VectorObject *self)
162
 
{
163
 
        if (self->wrapped==Py_WRAP) {
164
 
                PyErr_SetString(PyExc_TypeError, "vector.resize3D(): cannot resize wrapped data - only python vectors\n");
165
 
                return NULL;
166
 
        }
167
 
        if(self->cb_user) {
168
 
                PyErr_SetString(PyExc_TypeError, "vector.resize3D(): cannot resize a vector that has an owner");
169
 
                return NULL;
170
 
        }
171
 
        
172
 
        self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 3));
173
 
        if(self->vec == NULL) {
174
 
                PyErr_SetString(PyExc_MemoryError, "vector.resize3D(): problem allocating pointer space\n\n");
175
 
                return NULL;
176
 
        }
177
 
        
178
 
        if(self->size == 2)
179
 
                self->vec[2] = 0.0f;
180
 
        
181
 
        self->size = 3;
182
 
        Py_INCREF(self);
183
 
        return (PyObject*)self;
184
 
}
185
 
/*----------------------------Vector.resize4D() ------------------ */
186
 
static char Vector_Resize4D_doc[] =
187
 
".. method:: resize4D()\n"
188
 
"\n"
189
 
"   Resize the vector to 4D (x, y, z, w).\n"
190
 
"\n"
191
 
"   :return: an instance of itself\n"
192
 
"   :rtype: :class:`Vector`\n";
193
 
 
194
 
static PyObject *Vector_Resize4D(VectorObject *self)
195
 
{
196
 
        if(self->wrapped==Py_WRAP) {
197
 
                PyErr_SetString(PyExc_TypeError, "vector.resize4D(): cannot resize wrapped data - only python vectors");
198
 
                return NULL;
199
 
        }
200
 
        if(self->cb_user) {
201
 
                PyErr_SetString(PyExc_TypeError, "vector.resize4D(): cannot resize a vector that has an owner");
202
 
                return NULL;
203
 
        }
204
 
        
205
 
        self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 4));
206
 
        if(self->vec == NULL) {
207
 
                PyErr_SetString(PyExc_MemoryError, "vector.resize4D(): problem allocating pointer space\n\n");
208
 
                return NULL;
209
 
        }
210
 
        if(self->size == 2){
211
 
                self->vec[2] = 0.0f;
212
 
                self->vec[3] = 1.0f;
213
 
        }else if(self->size == 3){
214
 
                self->vec[3] = 1.0f;
215
 
        }
216
 
        self->size = 4;
217
 
        Py_INCREF(self);
218
 
        return (PyObject*)self;
219
 
}
220
 
 
221
 
/*----------------------------Vector.toTuple() ------------------ */
222
 
static char Vector_ToTuple_doc[] =
223
 
".. method:: to_tuple(precision=-1)\n"
224
 
"\n"
225
 
"   Return this vector as a tuple with.\n"
226
 
"\n"
227
 
"   :arg precision: The number to round the value to in [-1, 21].\n"
228
 
"   :type precision: int\n"
229
 
"   :return: the values of the vector rounded by *precision*\n"
230
 
"   :rtype: tuple\n";
231
 
 
232
 
/* note: BaseMath_ReadCallback must be called beforehand */
233
 
static PyObject *Vector_ToTupleExt(VectorObject *self, int ndigits)
234
 
{
235
 
        PyObject *ret;
236
 
        int i;
237
 
 
238
 
        ret= PyTuple_New(self->size);
239
 
 
240
 
        if(ndigits >= 0) {
241
 
                for(i = 0; i < self->size; i++) {
242
 
                        PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->vec[i], ndigits)));
243
 
                }
244
 
        }
245
 
        else {
246
 
                for(i = 0; i < self->size; i++) {
247
 
                        PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->vec[i]));
248
 
                }
249
 
        }
250
 
 
251
 
        return ret;
252
 
}
253
 
 
254
 
static PyObject *Vector_ToTuple(VectorObject *self, PyObject *args)
255
 
{
256
 
        int ndigits= 0;
257
 
 
258
 
        if(!PyArg_ParseTuple(args, "|i:to_tuple", &ndigits))
259
 
                return NULL;
260
 
 
261
 
        if(ndigits > 22 || ndigits < 0) {
262
 
                PyErr_SetString(PyExc_ValueError, "vector.to_tuple(ndigits): ndigits must be between 0 and 21");
263
 
                return NULL;
264
 
        }
265
 
 
266
 
        if(PyTuple_GET_SIZE(args)==0)
267
 
                ndigits= -1;
268
 
 
269
 
        if(!BaseMath_ReadCallback(self))
270
 
                return NULL;
271
 
 
272
 
        return Vector_ToTupleExt(self, ndigits);
273
 
}
274
 
 
275
 
/*----------------------------Vector.toTrackQuat(track, up) ---------------------- */
276
 
static char Vector_ToTrackQuat_doc[] =
277
 
".. method:: to_track_quat(track, up)\n"
278
 
"\n"
279
 
"   Return a quaternion rotation from the vector and the track and up axis.\n"
280
 
"\n"
281
 
"   :arg track: Track axis in ['X', 'Y', 'Z', '-X', '-Y', '-Z'].\n"
282
 
"   :type track: string\n"
283
 
"   :arg up: Up axis in ['X', 'Y', 'Z'].\n"
284
 
"   :type up: string\n"
285
 
"   :return: rotation from the vector and the track and up axis.\n"
286
 
"   :rtype: :class:`Quaternion`\n";
287
 
 
288
 
static PyObject *Vector_ToTrackQuat(VectorObject *self, PyObject *args )
289
 
{
290
 
        float vec[3], quat[4];
291
 
        char *strack, *sup;
292
 
        short track = 2, up = 1;
293
 
 
294
 
        if(!PyArg_ParseTuple( args, "|ss:to_track_quat", &strack, &sup))
295
 
                return NULL;
296
 
 
297
 
        if (self->size != 3) {
298
 
                PyErr_SetString( PyExc_TypeError, "only for 3D vectors\n" );
299
 
                return NULL;
300
 
        }
301
 
        
302
 
        if(!BaseMath_ReadCallback(self))
303
 
                return NULL;
304
 
 
305
 
        if (strack) {
306
 
                if (strlen(strack) == 2) {
307
 
                        if (strack[0] == '-') {
308
 
                                switch(strack[1]) {
309
 
                                        case 'X':
310
 
                                                track = 3;
311
 
                                                break;
312
 
                                        case 'Y':
313
 
                                                track = 4;
314
 
                                                break;
315
 
                                        case 'Z':
316
 
                                                track = 5;
317
 
                                                break;
318
 
                                        default:
319
 
                                                PyErr_SetString( PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis\n" );
320
 
                                                return NULL;
321
 
                                }
322
 
                        }
323
 
                        else {
324
 
                                PyErr_SetString( PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis\n" );
325
 
                                return NULL;
326
 
                        }
327
 
                }
328
 
                else if (strlen(strack) == 1) {
329
 
                        switch(strack[0]) {
330
 
                        case '-':
331
 
                        case 'X':
332
 
                                track = 0;
333
 
                                break;
334
 
                        case 'Y':
335
 
                                track = 1;
336
 
                                break;
337
 
                        case 'Z':
338
 
                                track = 2;
339
 
                                break;
340
 
                        default:
341
 
                                PyErr_SetString( PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis\n" );
342
 
                                return NULL;
343
 
                        }
344
 
                }
345
 
                else {
346
 
                        PyErr_SetString( PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis\n" );
347
 
                        return NULL;
348
 
                }
349
 
        }
350
 
 
351
 
        if (sup) {
352
 
                if (strlen(sup) == 1) {
353
 
                        switch(*sup) {
354
 
                        case 'X':
355
 
                                up = 0;
356
 
                                break;
357
 
                        case 'y':
358
 
                                up = 1;
359
 
                                break;
360
 
                        case 'Z':
361
 
                                up = 2;
362
 
                                break;
363
 
                        default:
364
 
                                PyErr_SetString( PyExc_ValueError, "only X, Y or Z for up axis\n" );
365
 
                                return NULL;
366
 
                        }
367
 
                }
368
 
                else {
369
 
                        PyErr_SetString( PyExc_ValueError, "only X, Y or Z for up axis\n" );
370
 
                        return NULL;
371
 
                }
372
 
        }
373
 
 
374
 
        if (track == up) {
375
 
                PyErr_SetString( PyExc_ValueError, "Can't have the same axis for track and up\n" );
376
 
                return NULL;
377
 
        }
378
 
 
379
 
        /*
380
 
                flip vector around, since vectoquat expect a vector from target to tracking object 
381
 
                and the python function expects the inverse (a vector to the target).
382
 
        */
383
 
        vec[0] = -self->vec[0];
384
 
        vec[1] = -self->vec[1];
385
 
        vec[2] = -self->vec[2];
386
 
 
387
 
        vec_to_quat( quat,vec, track, up);
388
 
 
389
 
        return newQuaternionObject(quat, Py_NEW, NULL);
390
 
}
391
 
 
392
 
/*----------------------------Vector.reflect(mirror) ----------------------
393
 
  return a reflected vector on the mirror normal
394
 
   vec - ((2 * DotVecs(vec, mirror)) * mirror)
395
 
*/
396
 
static char Vector_Reflect_doc[] =
397
 
".. method:: reflect(mirror)\n"
398
 
"\n"
399
 
"   Return the reflection vector from the *mirror* argument.\n"
400
 
"\n"
401
 
"   :arg mirror: This vector could be a normal from the reflecting surface.\n"
402
 
"   :type mirror: :class:`Vector`\n"
403
 
"   :return: The reflected vector matching the size of this vector.\n"
404
 
"   :rtype: :class:`Vector`\n";
405
 
 
406
 
static PyObject *Vector_Reflect(VectorObject *self, VectorObject *value )
407
 
{
408
 
        float mirror[3], vec[3];
409
 
        float reflect[3] = {0.0f, 0.0f, 0.0f};
410
 
        
411
 
        if (!VectorObject_Check(value)) {
412
 
                PyErr_SetString( PyExc_TypeError, "vec.reflect(value): expected a vector argument" );
413
 
                return NULL;
414
 
        }
415
 
        
416
 
        if(!BaseMath_ReadCallback(self) || !BaseMath_ReadCallback(value))
417
 
                return NULL;
418
 
        
419
 
        mirror[0] = value->vec[0];
420
 
        mirror[1] = value->vec[1];
421
 
        if (value->size > 2)    mirror[2] = value->vec[2];
422
 
        else                                    mirror[2] = 0.0;
423
 
        
424
 
        vec[0] = self->vec[0];
425
 
        vec[1] = self->vec[1];
426
 
        if (self->size > 2)             vec[2] = self->vec[2];
427
 
        else                                    vec[2] = 0.0;
428
 
        
429
 
        normalize_v3(mirror);
430
 
        reflect_v3_v3v3(reflect, vec, mirror);
431
 
        
432
 
        return newVectorObject(reflect, self->size, Py_NEW, NULL);
433
 
}
434
 
 
435
 
static char Vector_Cross_doc[] =
436
 
".. method:: cross(other)\n"
437
 
"\n"
438
 
"   Return the cross product of this vector and another.\n"
439
 
"\n"
440
 
"   :arg other: The other vector to perform the cross product with.\n"
441
 
"   :type other: :class:`Vector`\n"
442
 
"   :return: The cross product.\n"
443
 
"   :rtype: :class:`Vector`\n"
444
 
"\n"
445
 
"   .. note:: both vectors must be 3D\n";
446
 
 
447
 
static PyObject *Vector_Cross(VectorObject *self, VectorObject *value )
448
 
{
449
 
        VectorObject *vecCross = NULL;
450
 
 
451
 
        if (!VectorObject_Check(value)) {
452
 
                PyErr_SetString( PyExc_TypeError, "vec.cross(value): expected a vector argument" );
453
 
                return NULL;
454
 
        }
455
 
        
456
 
        if(self->size != 3 || value->size != 3) {
457
 
                PyErr_SetString(PyExc_AttributeError, "vec.cross(value): expects both vectors to be 3D\n");
458
 
                return NULL;
459
 
        }
460
 
        
461
 
        if(!BaseMath_ReadCallback(self) || !BaseMath_ReadCallback(value))
462
 
                return NULL;
463
 
        
464
 
        vecCross = (VectorObject *)newVectorObject(NULL, 3, Py_NEW, NULL);
465
 
        cross_v3_v3v3(vecCross->vec, self->vec, value->vec);
466
 
        return (PyObject *)vecCross;
467
 
}
468
 
 
469
 
static char Vector_Dot_doc[] =
470
 
".. method:: dot(other)\n"
471
 
"\n"
472
 
"   Return the dot product of this vector and another.\n"
473
 
"\n"
474
 
"   :arg other: The other vector to perform the dot product with.\n"
475
 
"   :type other: :class:`Vector`\n"
476
 
"   :return: The dot product.\n"
477
 
"   :rtype: :class:`Vector`\n";
478
 
 
479
 
static PyObject *Vector_Dot(VectorObject *self, VectorObject *value )
480
 
{
481
 
        double dot = 0.0;
482
 
        int x;
483
 
        
484
 
        if (!VectorObject_Check(value)) {
485
 
                PyErr_SetString( PyExc_TypeError, "vec.dot(value): expected a vector argument" );
486
 
                return NULL;
487
 
        }
488
 
        
489
 
        if(self->size != value->size) {
490
 
                PyErr_SetString(PyExc_AttributeError, "vec.dot(value): expects both vectors to have the same size\n");
491
 
                return NULL;
492
 
        }
493
 
        
494
 
        if(!BaseMath_ReadCallback(self) || !BaseMath_ReadCallback(value))
495
 
                return NULL;
496
 
        
497
 
        for(x = 0; x < self->size; x++) {
498
 
                dot += self->vec[x] * value->vec[x];
499
 
        }
500
 
        return PyFloat_FromDouble(dot);
501
 
}
502
 
 
503
 
static char Vector_angle_doc[] = 
504
 
".. function:: angle(other, fallback)\n"
505
 
"\n"
506
 
"   Return the angle between two vectors.\n"
507
 
"\n"
508
 
"   :arg other: another vector to compare the angle with\n"
509
 
"   :type other: :class:`Vector`\n"
510
 
"   :arg fallback: return this value when the angle cant be calculated (zero length vector)\n"
511
 
"   :return angle: angle in radians or fallback when given\n"
512
 
"   :rtype: float\n"
513
 
"\n"
514
 
"   .. note:: Zero length vectors raise an :exc:`AttributeError`.\n";
515
 
static PyObject *Vector_angle(VectorObject *self, PyObject *args)
516
 
{
517
 
        VectorObject *value;
518
 
        double dot = 0.0f, angleRads, test_v1 = 0.0f, test_v2 = 0.0f;
519
 
        int x, size;
520
 
        PyObject *fallback= NULL;
521
 
        
522
 
        if(!PyArg_ParseTuple(args, "O!|O:angle", &vector_Type, &value, &fallback))
523
 
                return NULL;
524
 
 
525
 
        if (!VectorObject_Check(value)) {
526
 
                PyErr_SetString( PyExc_TypeError, "vec.angle(value): expected a vector argument" );
527
 
                return NULL;
528
 
        }
529
 
        
530
 
        if(self->size != value->size) {
531
 
                PyErr_SetString(PyExc_AttributeError, "vec.angle(value): expects both vectors to have the same size\n");
532
 
                return NULL;
533
 
        }
534
 
        
535
 
        if(!BaseMath_ReadCallback(self) || !BaseMath_ReadCallback(value))
536
 
                return NULL;
537
 
 
538
 
        //since size is the same....
539
 
        size = self->size;
540
 
 
541
 
        for(x = 0; x < size; x++) {
542
 
                test_v1 += self->vec[x] * self->vec[x];
543
 
                test_v2 += value->vec[x] * value->vec[x];
544
 
        }
545
 
        if (!test_v1 || !test_v2){
546
 
                /* avoid exception */
547
 
                if(fallback) {
548
 
                        Py_INCREF(fallback);
549
 
                        return fallback;
550
 
                }
551
 
                else {
552
 
                        PyErr_SetString(PyExc_ValueError, "vector.angle(other): zero length vectors have no valid angle\n");
553
 
                        return NULL;
554
 
                }
555
 
        }
556
 
 
557
 
        //dot product
558
 
        for(x = 0; x < size; x++) {
559
 
                dot += self->vec[x] * value->vec[x];
560
 
        }
561
 
        dot /= (sqrt(test_v1) * sqrt(test_v2));
562
 
 
563
 
        angleRads = (double)saacos(dot);
564
 
 
565
 
        return PyFloat_FromDouble(angleRads);
566
 
}
567
 
 
568
 
static char Vector_Difference_doc[] =
569
 
".. function:: difference(other)\n"
570
 
"\n"
571
 
"   Returns a quaternion representing the rotational difference between this vector and another.\n"
572
 
"\n"
573
 
"   :arg other: second vector.\n"
574
 
"   :type other: :class:`Vector`\n"
575
 
"   :return: the rotational difference between the two vectors.\n"
576
 
"   :rtype: :class:`Quaternion`\n"
577
 
"\n"
578
 
"   .. note:: 2D vectors raise an :exc:`AttributeError`.\n";;
579
 
 
580
 
static PyObject *Vector_Difference(VectorObject *self, VectorObject *value )
581
 
{
582
 
        float quat[4], vec_a[3], vec_b[3];
583
 
 
584
 
        if (!VectorObject_Check(value)) {
585
 
                PyErr_SetString( PyExc_TypeError, "vec.difference(value): expected a vector argument" );
586
 
                return NULL;
587
 
        }
588
 
 
589
 
        if(self->size < 3 || value->size < 3) {
590
 
                PyErr_SetString(PyExc_AttributeError, "vec.difference(value): expects both vectors to be size 3 or 4\n");
591
 
                return NULL;
592
 
        }
593
 
 
594
 
        if(!BaseMath_ReadCallback(self) || !BaseMath_ReadCallback(value))
595
 
                return NULL;
596
 
 
597
 
        normalize_v3_v3(vec_a, self->vec);
598
 
        normalize_v3_v3(vec_b, value->vec);
599
 
 
600
 
        rotation_between_vecs_to_quat(quat, vec_a, vec_b);
601
 
 
602
 
        return newQuaternionObject(quat, Py_NEW, NULL);
603
 
}
604
 
 
605
 
static char Vector_Project_doc[] =
606
 
".. function:: project(other)\n"
607
 
"\n"
608
 
"   Return the projection of this vector onto the *other*.\n"
609
 
"\n"
610
 
"   :type other: :class:`Vector`\n"
611
 
"   :return projection: the parallel projection vector\n"
612
 
"   :rtype: :class:`Vector`\n";
613
 
 
614
 
static PyObject *Vector_Project(VectorObject *self, VectorObject *value)
615
 
{
616
 
        float vec[4];
617
 
        double dot = 0.0f, dot2 = 0.0f;
618
 
        int x, size;
619
 
 
620
 
        if (!VectorObject_Check(value)) {
621
 
                PyErr_SetString( PyExc_TypeError, "vec.project(value): expected a vector argument" );
622
 
                return NULL;
623
 
        }
624
 
 
625
 
        if(self->size != value->size) {
626
 
                PyErr_SetString(PyExc_AttributeError, "vec.project(value): expects both vectors to have the same size\n");
627
 
                return NULL;
628
 
        }
629
 
 
630
 
        if(!BaseMath_ReadCallback(self) || !BaseMath_ReadCallback(value))
631
 
                return NULL;
632
 
 
633
 
 
634
 
        //since they are the same size...
635
 
        size = self->size;
636
 
 
637
 
        //get dot products
638
 
        for(x = 0; x < size; x++) {
639
 
                dot += self->vec[x] * value->vec[x];
640
 
                dot2 += value->vec[x] * value->vec[x];
641
 
        }
642
 
        //projection
643
 
        dot /= dot2;
644
 
        for(x = 0; x < size; x++) {
645
 
                vec[x] = (float)(dot * value->vec[x]);
646
 
        }
647
 
        return newVectorObject(vec, size, Py_NEW, NULL);
648
 
}
649
 
 
650
 
static char Vector_Lerp_doc[] =
651
 
".. function:: lerp(other, factor)\n"
652
 
"\n"
653
 
"   Returns the interpolation of two vectors.\n"
654
 
"\n"
655
 
"   :arg other: value to interpolate with.\n"
656
 
"   :type other: :class:`Vector`\n"
657
 
"   :arg factor: The interpolation value in [0.0, 1.0].\n"
658
 
"   :type factor: float\n"
659
 
"   :return: The interpolated rotation.\n"
660
 
"   :rtype: :class:`Vector`\n";
661
 
 
662
 
static PyObject *Vector_Lerp(VectorObject *self, PyObject *args)
663
 
{
664
 
        VectorObject *vec2 = NULL;
665
 
        float fac, ifac, vec[4];
666
 
        int x;
667
 
 
668
 
        if(!PyArg_ParseTuple(args, "O!f:lerp", &vector_Type, &vec2, &fac))
669
 
                return NULL;
670
 
 
671
 
        if(self->size != vec2->size) {
672
 
                PyErr_SetString(PyExc_AttributeError, "vector.lerp(): expects (2) vector objects of the same size");
673
 
                return NULL;
674
 
        }
675
 
 
676
 
        if(!BaseMath_ReadCallback(self) || !BaseMath_ReadCallback(vec2))
677
 
                return NULL;
678
 
 
679
 
        ifac= 1.0 - fac;
680
 
 
681
 
        for(x = 0; x < self->size; x++) {
682
 
                vec[x] = (ifac * self->vec[x]) + (fac * vec2->vec[x]);
683
 
        }
684
 
        return newVectorObject(vec, self->size, Py_NEW, NULL);
685
 
}
686
 
 
687
 
/*----------------------------Vector.copy() -------------------------------------- */
688
 
static char Vector_copy_doc[] =
689
 
".. function:: copy()\n"
690
 
"\n"
691
 
"   Returns a copy of this vector.\n"
692
 
"\n"
693
 
"   :return: A copy of the vector.\n"
694
 
"   :rtype: :class:`Vector`\n"
695
 
"\n"
696
 
"   .. note:: use this to get a copy of a wrapped vector with no reference to the original data.\n";
697
 
 
698
 
static PyObject *Vector_copy(VectorObject *self)
699
 
{
700
 
        if(!BaseMath_ReadCallback(self))
701
 
                return NULL;
702
 
        
703
 
        return newVectorObject(self->vec, self->size, Py_NEW, Py_TYPE(self));
704
 
}
705
 
 
706
 
/*----------------------------print object (internal)-------------
707
 
  print the object to screen */
708
 
static PyObject *Vector_repr(VectorObject *self)
709
 
{
710
 
        PyObject *ret, *tuple;
711
 
 
712
 
        if(!BaseMath_ReadCallback(self))
713
 
                return NULL;
714
 
 
715
 
        tuple= Vector_ToTupleExt(self, -1);
716
 
        ret= PyUnicode_FromFormat("Vector(%R)", tuple);
717
 
        Py_DECREF(tuple);
718
 
        return ret;
719
 
}
720
 
 
721
 
/*---------------------SEQUENCE PROTOCOLS------------------------
722
 
  ----------------------------len(object)------------------------
723
 
  sequence length*/
724
 
static int Vector_len(VectorObject *self)
725
 
{
726
 
        return self->size;
727
 
}
728
 
/*----------------------------object[]---------------------------
729
 
  sequence accessor (get)*/
730
 
static PyObject *Vector_item(VectorObject *self, int i)
731
 
{
732
 
        if(i<0) i= self->size-i;
733
 
 
734
 
        if(i < 0 || i >= self->size) {
735
 
                PyErr_SetString(PyExc_IndexError,"vector[index]: out of range\n");
736
 
                return NULL;
737
 
        }
738
 
 
739
 
        if(!BaseMath_ReadIndexCallback(self, i))
740
 
                return NULL;
741
 
        
742
 
        return PyFloat_FromDouble(self->vec[i]);
743
 
 
744
 
}
745
 
/*----------------------------object[]-------------------------
746
 
  sequence accessor (set)*/
747
 
static int Vector_ass_item(VectorObject *self, int i, PyObject * ob)
748
 
{
749
 
        float scalar;
750
 
        if((scalar=PyFloat_AsDouble(ob))==-1.0f && PyErr_Occurred()) { /* parsed item not a number */
751
 
                PyErr_SetString(PyExc_TypeError, "vector[index] = x: index argument not a number\n");
752
 
                return -1;
753
 
        }
754
 
 
755
 
        if(i<0) i= self->size-i;
756
 
 
757
 
        if(i < 0 || i >= self->size){
758
 
                PyErr_SetString(PyExc_IndexError, "vector[index] = x: assignment index out of range\n");
759
 
                return -1;
760
 
        }
761
 
        self->vec[i] = scalar;
762
 
        
763
 
        if(!BaseMath_WriteIndexCallback(self, i))
764
 
                return -1;
765
 
        return 0;
766
 
}
767
 
 
768
 
/*----------------------------object[z:y]------------------------
769
 
  sequence slice (get) */
770
 
static PyObject *Vector_slice(VectorObject *self, int begin, int end)
771
 
{
772
 
        PyObject *list = NULL;
773
 
        int count;
774
 
 
775
 
        if(!BaseMath_ReadCallback(self))
776
 
                return NULL;
777
 
        
778
 
        CLAMP(begin, 0, self->size);
779
 
        if (end<0) end= self->size+end+1;
780
 
        CLAMP(end, 0, self->size);
781
 
        begin = MIN2(begin,end);
782
 
 
783
 
        list = PyList_New(end - begin);
784
 
        for(count = begin; count < end; count++) {
785
 
                PyList_SET_ITEM(list, count - begin, PyFloat_FromDouble(self->vec[count]));
786
 
        }
787
 
 
788
 
        return list;
789
 
}
790
 
/*----------------------------object[z:y]------------------------
791
 
  sequence slice (set) */
792
 
static int Vector_ass_slice(VectorObject *self, int begin, int end,
793
 
                                 PyObject * seq)
794
 
{
795
 
        int i, y, size = 0;
796
 
        float vec[4], scalar;
797
 
        PyObject *v;
798
 
 
799
 
        if(!BaseMath_ReadCallback(self))
800
 
                return -1;
801
 
        
802
 
        CLAMP(begin, 0, self->size);
803
 
        if (end<0) end= self->size+end+1;
804
 
        CLAMP(end, 0, self->size);
805
 
        begin = MIN2(begin,end);
806
 
 
807
 
        size = PySequence_Length(seq);
808
 
        if(size != (end - begin)){
809
 
                PyErr_SetString(PyExc_TypeError, "vector[begin:end] = []: size mismatch in slice assignment\n");
810
 
                return -1;
811
 
        }
812
 
 
813
 
        for (i = 0; i < size; i++) {
814
 
                v = PySequence_GetItem(seq, i);
815
 
                if (v == NULL) { /* Failed to read sequence */
816
 
                        PyErr_SetString(PyExc_RuntimeError, "vector[begin:end] = []: unable to read sequence\n");
817
 
                        return -1;
818
 
                }
819
 
                
820
 
                if((scalar=PyFloat_AsDouble(v)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
821
 
                        Py_DECREF(v);
822
 
                        PyErr_SetString(PyExc_TypeError, "vector[begin:end] = []: sequence argument not a number\n");
823
 
                        return -1;
824
 
                }
825
 
 
826
 
                vec[i] = scalar;
827
 
                Py_DECREF(v);
828
 
        }
829
 
        /*parsed well - now set in vector*/
830
 
        for(y = 0; y < size; y++){
831
 
                self->vec[begin + y] = vec[y];
832
 
        }
833
 
        
834
 
        if(!BaseMath_WriteCallback(self))
835
 
                return -1;
836
 
        
837
 
        return 0;
838
 
}
839
 
/*------------------------NUMERIC PROTOCOLS----------------------
840
 
  ------------------------obj + obj------------------------------
841
 
  addition*/
842
 
static PyObject *Vector_add(PyObject * v1, PyObject * v2)
843
 
{
844
 
        int i;
845
 
        float vec[4];
846
 
 
847
 
        VectorObject *vec1 = NULL, *vec2 = NULL;
848
 
        
849
 
        if VectorObject_Check(v1)
850
 
                vec1= (VectorObject *)v1;
851
 
        
852
 
        if VectorObject_Check(v2)
853
 
                vec2= (VectorObject *)v2;
854
 
        
855
 
        /* make sure v1 is always the vector */
856
 
        if (vec1 && vec2 ) {
857
 
                
858
 
                if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2))
859
 
                        return NULL;
860
 
                
861
 
                /*VECTOR + VECTOR*/
862
 
                if(vec1->size != vec2->size) {
863
 
                        PyErr_SetString(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation\n");
864
 
                        return NULL;
865
 
                }
866
 
                for(i = 0; i < vec1->size; i++) {
867
 
                        vec[i] = vec1->vec[i] + vec2->vec[i];
868
 
                }
869
 
                return newVectorObject(vec, vec1->size, Py_NEW, NULL);
870
 
        }
871
 
        
872
 
        PyErr_SetString(PyExc_AttributeError, "Vector addition: arguments not valid for this operation....\n");
873
 
        return NULL;
874
 
}
875
 
 
876
 
/*  ------------------------obj += obj------------------------------
877
 
  addition in place */
878
 
static PyObject *Vector_iadd(PyObject * v1, PyObject * v2)
879
 
{
880
 
        int i;
881
 
        VectorObject *vec1 = NULL, *vec2 = NULL;
882
 
 
883
 
        if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
884
 
                PyErr_SetString(PyExc_AttributeError, "Vector addition: arguments not valid for this operation....\n");
885
 
                return NULL;
886
 
        }
887
 
        vec1 = (VectorObject*)v1;
888
 
        vec2 = (VectorObject*)v2;
889
 
        
890
 
        if(vec1->size != vec2->size) {
891
 
                PyErr_SetString(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation\n");
892
 
                return NULL;
893
 
        }
894
 
        
895
 
        if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2))
896
 
                return NULL;
897
 
 
898
 
        for(i = 0; i < vec1->size; i++) {
899
 
                vec1->vec[i] = vec1->vec[i] + vec2->vec[i];
900
 
        }
901
 
 
902
 
        BaseMath_WriteCallback(vec1);
903
 
        Py_INCREF( v1 );
904
 
        return v1;
905
 
}
906
 
 
907
 
/*------------------------obj - obj------------------------------
908
 
  subtraction*/
909
 
static PyObject *Vector_sub(PyObject * v1, PyObject * v2)
910
 
{
911
 
        int i;
912
 
        float vec[4];
913
 
        VectorObject *vec1 = NULL, *vec2 = NULL;
914
 
 
915
 
        if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
916
 
                PyErr_SetString(PyExc_AttributeError, "Vector subtraction: arguments not valid for this operation....\n");
917
 
                return NULL;
918
 
        }
919
 
        vec1 = (VectorObject*)v1;
920
 
        vec2 = (VectorObject*)v2;
921
 
        
922
 
        if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2))
923
 
                return NULL;
924
 
        
925
 
        if(vec1->size != vec2->size) {
926
 
                PyErr_SetString(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation\n");
927
 
                return NULL;
928
 
        }
929
 
        for(i = 0; i < vec1->size; i++) {
930
 
                vec[i] = vec1->vec[i] - vec2->vec[i];
931
 
        }
932
 
 
933
 
        return newVectorObject(vec, vec1->size, Py_NEW, NULL);
934
 
}
935
 
 
936
 
/*------------------------obj -= obj------------------------------
937
 
  subtraction*/
938
 
static PyObject *Vector_isub(PyObject * v1, PyObject * v2)
939
 
{
940
 
        int i;
941
 
        VectorObject *vec1 = NULL, *vec2 = NULL;
942
 
 
943
 
        if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
944
 
                PyErr_SetString(PyExc_AttributeError, "Vector subtraction: arguments not valid for this operation....\n");
945
 
                return NULL;
946
 
        }
947
 
        vec1 = (VectorObject*)v1;
948
 
        vec2 = (VectorObject*)v2;
949
 
        
950
 
        if(vec1->size != vec2->size) {
951
 
                PyErr_SetString(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation\n");
952
 
                return NULL;
953
 
        }
954
 
        
955
 
        if(!BaseMath_ReadCallback(vec1) || !BaseMath_ReadCallback(vec2))
956
 
                return NULL;
957
 
 
958
 
        for(i = 0; i < vec1->size; i++) {
959
 
                vec1->vec[i] = vec1->vec[i] -   vec2->vec[i];
960
 
        }
961
 
 
962
 
        BaseMath_WriteCallback(vec1);
963
 
        Py_INCREF( v1 );
964
 
        return v1;
965
 
}
966
 
 
967
 
/*------------------------obj * obj------------------------------
968
 
  mulplication*/
969
 
static PyObject *Vector_mul(PyObject * v1, PyObject * v2)
970
 
{
971
 
        VectorObject *vec1 = NULL, *vec2 = NULL;
972
 
        float scalar;
973
 
        
974
 
        if VectorObject_Check(v1) {
975
 
                vec1= (VectorObject *)v1;
976
 
                if(!BaseMath_ReadCallback(vec1))
977
 
                        return NULL;
978
 
        }
979
 
        if VectorObject_Check(v2) {
980
 
                vec2= (VectorObject *)v2;
981
 
                if(!BaseMath_ReadCallback(vec2))
982
 
                        return NULL;
983
 
        }
984
 
        
985
 
        
986
 
        /* make sure v1 is always the vector */
987
 
        if (vec1 && vec2 ) {
988
 
                int i;
989
 
                double dot = 0.0f;
990
 
                
991
 
                if(vec1->size != vec2->size) {
992
 
                        PyErr_SetString(PyExc_AttributeError, "Vector multiplication: vectors must have the same dimensions for this operation\n");
993
 
                        return NULL;
994
 
                }
995
 
                
996
 
                /*dot product*/
997
 
                for(i = 0; i < vec1->size; i++) {
998
 
                        dot += vec1->vec[i] * vec2->vec[i];
999
 
                }
1000
 
                return PyFloat_FromDouble(dot);
1001
 
        }
1002
 
        
1003
 
        /*swap so vec1 is always the vector */
1004
 
        if (vec2) {
1005
 
                vec1= vec2;
1006
 
                v2= v1;
1007
 
        }
1008
 
        
1009
 
        if (MatrixObject_Check(v2)) {
1010
 
                /* VEC * MATRIX */
1011
 
                return row_vector_multiplication(vec1, (MatrixObject*)v2);
1012
 
        } else if (QuaternionObject_Check(v2)) {
1013
 
                QuaternionObject *quat = (QuaternionObject*)v2; /* quat_rotation validates */
1014
 
 
1015
 
                if(vec1->size != 3) {
1016
 
                        PyErr_SetString(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported\n");
1017
 
                        return NULL;
1018
 
                }
1019
 
                return quat_rotation((PyObject*)vec1, (PyObject*)quat);
1020
 
        }
1021
 
        else if (((scalar= PyFloat_AsDouble(v2)) == -1.0 && PyErr_Occurred())==0) { /* VEC*FLOAT */
1022
 
                int i;
1023
 
                float vec[4];
1024
 
                
1025
 
                for(i = 0; i < vec1->size; i++) {
1026
 
                        vec[i] = vec1->vec[i] * scalar;
1027
 
                }
1028
 
                return newVectorObject(vec, vec1->size, Py_NEW, NULL);
1029
 
                
1030
 
        }
1031
 
        
1032
 
        PyErr_SetString(PyExc_TypeError, "Vector multiplication: arguments not acceptable for this operation\n");
1033
 
        return NULL;
1034
 
}
1035
 
 
1036
 
/*------------------------obj *= obj------------------------------
1037
 
  in place mulplication */
1038
 
static PyObject *Vector_imul(PyObject * v1, PyObject * v2)
1039
 
{
1040
 
        VectorObject *vec = (VectorObject *)v1;
1041
 
        int i;
1042
 
        float scalar;
1043
 
        
1044
 
        if(!BaseMath_ReadCallback(vec))
1045
 
                return NULL;
1046
 
        
1047
 
        /* only support vec*=float and vec*=mat
1048
 
           vec*=vec result is a float so that wont work */
1049
 
        if (MatrixObject_Check(v2)) {
1050
 
                float vecCopy[4];
1051
 
                int x,y, size = vec->size;
1052
 
                MatrixObject *mat= (MatrixObject*)v2;
1053
 
                
1054
 
                if(!BaseMath_ReadCallback(mat))
1055
 
                        return NULL;
1056
 
                
1057
 
                if(mat->colSize != size){
1058
 
                        if(mat->rowSize == 4 && vec->size != 3){
1059
 
                                PyErr_SetString(PyExc_AttributeError, "vector * matrix: matrix column size and the vector size must be the same");
1060
 
                                return NULL;
1061
 
                        } else {
1062
 
                                vecCopy[3] = 1.0f;
1063
 
                        }
1064
 
                }
1065
 
                
1066
 
                for(i = 0; i < size; i++){
1067
 
                        vecCopy[i] = vec->vec[i];
1068
 
                }
1069
 
                
1070
 
                size = MIN2(size, mat->colSize);
1071
 
                
1072
 
                /*muliplication*/
1073
 
                for(x = 0, i = 0; x < size; x++, i++) {
1074
 
                        double dot = 0.0f;
1075
 
                        for(y = 0; y < mat->rowSize; y++) {
1076
 
                                dot += mat->matrix[y][x] * vecCopy[y];
1077
 
                        }
1078
 
                        vec->vec[i] = (float)dot;
1079
 
                }
1080
 
        }
1081
 
        else if (((scalar= PyFloat_AsDouble(v2)) == -1.0 && PyErr_Occurred())==0) { /* VEC*=FLOAT */
1082
 
                
1083
 
                for(i = 0; i < vec->size; i++) {
1084
 
                        vec->vec[i] *=  scalar;
1085
 
                }
1086
 
        }
1087
 
        else {
1088
 
                PyErr_SetString(PyExc_TypeError, "Vector multiplication: arguments not acceptable for this operation\n");
1089
 
                return NULL;
1090
 
        }
1091
 
        
1092
 
        BaseMath_WriteCallback(vec);
1093
 
        Py_INCREF( v1 );
1094
 
        return v1;
1095
 
}
1096
 
 
1097
 
/*------------------------obj / obj------------------------------
1098
 
  divide*/
1099
 
static PyObject *Vector_div(PyObject * v1, PyObject * v2)
1100
 
{
1101
 
        int i;
1102
 
        float vec[4], scalar;
1103
 
        VectorObject *vec1 = NULL;
1104
 
        
1105
 
        if(!VectorObject_Check(v1)) { /* not a vector */
1106
 
                PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float\n");
1107
 
                return NULL;
1108
 
        }
1109
 
        vec1 = (VectorObject*)v1; /* vector */
1110
 
        
1111
 
        if(!BaseMath_ReadCallback(vec1))
1112
 
                return NULL;
1113
 
 
1114
 
        if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
1115
 
                PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float\n");
1116
 
                return NULL;
1117
 
        }
1118
 
        
1119
 
        if(scalar==0.0) {
1120
 
                PyErr_SetString(PyExc_ZeroDivisionError, "Vector division: divide by zero error.\n");
1121
 
                return NULL;
1122
 
        }
1123
 
        
1124
 
        for(i = 0; i < vec1->size; i++) {
1125
 
                vec[i] = vec1->vec[i] / scalar;
1126
 
        }
1127
 
        return newVectorObject(vec, vec1->size, Py_NEW, NULL);
1128
 
}
1129
 
 
1130
 
/*------------------------obj /= obj------------------------------
1131
 
  divide*/
1132
 
static PyObject *Vector_idiv(PyObject * v1, PyObject * v2)
1133
 
{
1134
 
        int i;
1135
 
        float scalar;
1136
 
        VectorObject *vec1 = (VectorObject*)v1;
1137
 
        
1138
 
        if(!BaseMath_ReadCallback(vec1))
1139
 
                return NULL;
1140
 
 
1141
 
        if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
1142
 
                PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float\n");
1143
 
                return NULL;
1144
 
        }
1145
 
 
1146
 
        if(scalar==0.0) {
1147
 
                PyErr_SetString(PyExc_ZeroDivisionError, "Vector division: divide by zero error.\n");
1148
 
                return NULL;
1149
 
        }
1150
 
        for(i = 0; i < vec1->size; i++) {
1151
 
                vec1->vec[i] /= scalar;
1152
 
        }
1153
 
        
1154
 
        BaseMath_WriteCallback(vec1);
1155
 
        
1156
 
        Py_INCREF( v1 );
1157
 
        return v1;
1158
 
}
1159
 
 
1160
 
/*-------------------------- -obj -------------------------------
1161
 
  returns the negative of this object*/
1162
 
static PyObject *Vector_neg(VectorObject *self)
1163
 
{
1164
 
        int i;
1165
 
        float vec[4];
1166
 
        
1167
 
        if(!BaseMath_ReadCallback(self))
1168
 
                return NULL;
1169
 
        
1170
 
        for(i = 0; i < self->size; i++){
1171
 
                vec[i] = -self->vec[i];
1172
 
        }
1173
 
 
1174
 
        return newVectorObject(vec, self->size, Py_NEW, Py_TYPE(self));
1175
 
}
1176
 
 
1177
 
/*------------------------vec_magnitude_nosqrt (internal) - for comparing only */
1178
 
static double vec_magnitude_nosqrt(float *data, int size)
1179
 
{
1180
 
        double dot = 0.0f;
1181
 
        int i;
1182
 
 
1183
 
        for(i=0; i<size; i++){
1184
 
                dot += data[i];
1185
 
        }
1186
 
        /*return (double)sqrt(dot);*/
1187
 
        /* warning, line above removed because we are not using the length,
1188
 
           rather the comparing the sizes and for this we do not need the sqrt
1189
 
           for the actual length, the dot must be sqrt'd */
1190
 
        return (double)dot;
1191
 
}
1192
 
 
1193
 
 
1194
 
/*------------------------tp_richcmpr
1195
 
  returns -1 execption, 0 false, 1 true */
1196
 
static PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_type)
1197
 
{
1198
 
        VectorObject *vecA = NULL, *vecB = NULL;
1199
 
        int result = 0;
1200
 
        float epsilon = .000001f;
1201
 
        double lenA,lenB;
1202
 
 
1203
 
        if (!VectorObject_Check(objectA) || !VectorObject_Check(objectB)){
1204
 
                if (comparison_type == Py_NE){
1205
 
                        Py_RETURN_TRUE;
1206
 
                }else{
1207
 
                        Py_RETURN_FALSE;
1208
 
                }
1209
 
        }
1210
 
        vecA = (VectorObject*)objectA;
1211
 
        vecB = (VectorObject*)objectB;
1212
 
 
1213
 
        if(!BaseMath_ReadCallback(vecA) || !BaseMath_ReadCallback(vecB))
1214
 
                return NULL;
1215
 
        
1216
 
        if (vecA->size != vecB->size){
1217
 
                if (comparison_type == Py_NE){
1218
 
                        Py_RETURN_TRUE;
1219
 
                }else{
1220
 
                        Py_RETURN_FALSE;
1221
 
                }
1222
 
        }
1223
 
 
1224
 
        switch (comparison_type){
1225
 
                case Py_LT:
1226
 
                        lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
1227
 
                        lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
1228
 
                        if( lenA < lenB ){
1229
 
                                result = 1;
1230
 
                        }
1231
 
                        break;
1232
 
                case Py_LE:
1233
 
                        lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
1234
 
                        lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
1235
 
                        if( lenA < lenB ){
1236
 
                                result = 1;
1237
 
                        }else{
1238
 
                                result = (((lenA + epsilon) > lenB) && ((lenA - epsilon) < lenB));
1239
 
                        }
1240
 
                        break;
1241
 
                case Py_EQ:
1242
 
                        result = EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->size, 1);
1243
 
                        break;
1244
 
                case Py_NE:
1245
 
                        result = !EXPP_VectorsAreEqual(vecA->vec, vecB->vec, vecA->size, 1);
1246
 
                        break;
1247
 
                case Py_GT:
1248
 
                        lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
1249
 
                        lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
1250
 
                        if( lenA > lenB ){
1251
 
                                result = 1;
1252
 
                        }
1253
 
                        break;
1254
 
                case Py_GE:
1255
 
                        lenA = vec_magnitude_nosqrt(vecA->vec, vecA->size);
1256
 
                        lenB = vec_magnitude_nosqrt(vecB->vec, vecB->size);
1257
 
                        if( lenA > lenB ){
1258
 
                                result = 1;
1259
 
                        }else{
1260
 
                                result = (((lenA + epsilon) > lenB) && ((lenA - epsilon) < lenB));
1261
 
                        }
1262
 
                        break;
1263
 
                default:
1264
 
                        printf("The result of the comparison could not be evaluated");
1265
 
                        break;
1266
 
        }
1267
 
        if (result == 1){
1268
 
                Py_RETURN_TRUE;
1269
 
        }else{
1270
 
                Py_RETURN_FALSE;
1271
 
        }
1272
 
}
1273
 
 
1274
 
/*-----------------PROTCOL DECLARATIONS--------------------------*/
1275
 
static PySequenceMethods Vector_SeqMethods = {
1276
 
        (lenfunc) Vector_len,                           /* sq_length */
1277
 
        (binaryfunc) 0,                                         /* sq_concat */
1278
 
        (ssizeargfunc) 0,                                       /* sq_repeat */
1279
 
        (ssizeargfunc) Vector_item,                     /* sq_item */
1280
 
        NULL,                                                           /* py3 deprecated slice func */
1281
 
        (ssizeobjargproc) Vector_ass_item,      /* sq_ass_item */
1282
 
        NULL,                                                           /* py3 deprecated slice assign func */
1283
 
        (objobjproc) NULL,                                      /* sq_contains */
1284
 
        (binaryfunc) NULL,                                      /* sq_inplace_concat */
1285
 
        (ssizeargfunc) NULL,                            /* sq_inplace_repeat */
1286
 
};
1287
 
 
1288
 
static PyObject *Vector_subscript(VectorObject* self, PyObject* item)
1289
 
{
1290
 
        if (PyIndex_Check(item)) {
1291
 
                Py_ssize_t i;
1292
 
                i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1293
 
                if (i == -1 && PyErr_Occurred())
1294
 
                        return NULL;
1295
 
                if (i < 0)
1296
 
                        i += self->size;
1297
 
                return Vector_item(self, i);
1298
 
        } else if (PySlice_Check(item)) {
1299
 
                Py_ssize_t start, stop, step, slicelength;
1300
 
 
1301
 
                if (PySlice_GetIndicesEx((PySliceObject*)item, self->size, &start, &stop, &step, &slicelength) < 0)
1302
 
                        return NULL;
1303
 
 
1304
 
                if (slicelength <= 0) {
1305
 
                        return PyList_New(0);
1306
 
                }
1307
 
                else if (step == 1) {
1308
 
                        return Vector_slice(self, start, stop);
1309
 
                }
1310
 
                else {
1311
 
                        PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
1312
 
                        return NULL;
1313
 
                }
1314
 
        }
1315
 
        else {
1316
 
                PyErr_Format(PyExc_TypeError,
1317
 
                                 "vector indices must be integers, not %.200s",
1318
 
                                 item->ob_type->tp_name);
1319
 
                return NULL;
1320
 
        }
1321
 
}
1322
 
 
1323
 
static int Vector_ass_subscript(VectorObject* self, PyObject* item, PyObject* value)
1324
 
{
1325
 
        if (PyIndex_Check(item)) {
1326
 
                Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1327
 
                if (i == -1 && PyErr_Occurred())
1328
 
                        return -1;
1329
 
                if (i < 0)
1330
 
                        i += self->size;
1331
 
                return Vector_ass_item(self, i, value);
1332
 
        }
1333
 
        else if (PySlice_Check(item)) {
1334
 
                Py_ssize_t start, stop, step, slicelength;
1335
 
 
1336
 
                if (PySlice_GetIndicesEx((PySliceObject*)item, self->size, &start, &stop, &step, &slicelength) < 0)
1337
 
                        return -1;
1338
 
 
1339
 
                if (step == 1)
1340
 
                        return Vector_ass_slice(self, start, stop, value);
1341
 
                else {
1342
 
                        PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
1343
 
                        return -1;
1344
 
                }
1345
 
        }
1346
 
        else {
1347
 
                PyErr_Format(PyExc_TypeError,
1348
 
                                 "vector indices must be integers, not %.200s",
1349
 
                                 item->ob_type->tp_name);
1350
 
                return -1;
1351
 
        }
1352
 
}
1353
 
 
1354
 
static PyMappingMethods Vector_AsMapping = {
1355
 
        (lenfunc)Vector_len,
1356
 
        (binaryfunc)Vector_subscript,
1357
 
        (objobjargproc)Vector_ass_subscript
1358
 
};
1359
 
 
1360
 
 
1361
 
static PyNumberMethods Vector_NumMethods = {
1362
 
                (binaryfunc)    Vector_add,     /*nb_add*/
1363
 
                (binaryfunc)    Vector_sub,     /*nb_subtract*/
1364
 
                (binaryfunc)    Vector_mul,     /*nb_multiply*/
1365
 
                0,                                                      /*nb_remainder*/
1366
 
                0,                                                      /*nb_divmod*/
1367
 
                0,                                                      /*nb_power*/
1368
 
                (unaryfunc)     Vector_neg,     /*nb_negative*/
1369
 
                (unaryfunc)     0,      /*tp_positive*/
1370
 
                (unaryfunc)     0,      /*tp_absolute*/
1371
 
                (inquiry)       0,      /*tp_bool*/
1372
 
                (unaryfunc)     0,      /*nb_invert*/
1373
 
                0,                              /*nb_lshift*/
1374
 
                (binaryfunc)0,  /*nb_rshift*/
1375
 
                0,                              /*nb_and*/
1376
 
                0,                              /*nb_xor*/
1377
 
                0,                              /*nb_or*/
1378
 
                0,                              /*nb_int*/
1379
 
                0,                              /*nb_reserved*/
1380
 
                0,                              /*nb_float*/
1381
 
                Vector_iadd,    /* nb_inplace_add */
1382
 
                Vector_isub,    /* nb_inplace_subtract */
1383
 
                Vector_imul,    /* nb_inplace_multiply */
1384
 
                0,                              /* nb_inplace_remainder */
1385
 
                0,                              /* nb_inplace_power */
1386
 
                0,                              /* nb_inplace_lshift */
1387
 
                0,                              /* nb_inplace_rshift */
1388
 
                0,                              /* nb_inplace_and */
1389
 
                0,                              /* nb_inplace_xor */
1390
 
                0,                              /* nb_inplace_or */
1391
 
                0,                              /* nb_floor_divide */
1392
 
                Vector_div,             /* nb_true_divide */
1393
 
                0,                              /* nb_inplace_floor_divide */
1394
 
                Vector_idiv,    /* nb_inplace_true_divide */
1395
 
                0,                      /* nb_index */
1396
 
};
1397
 
 
1398
 
/*------------------PY_OBECT DEFINITION--------------------------*/
1399
 
 
1400
 
/*
1401
 
 * vector axis, vector.x/y/z/w
1402
 
 */
1403
 
        
1404
 
static PyObject *Vector_getAxis(VectorObject *self, void *type )
1405
 
{
1406
 
        return Vector_item(self, GET_INT_FROM_POINTER(type));
1407
 
}
1408
 
 
1409
 
static int Vector_setAxis(VectorObject *self, PyObject * value, void * type )
1410
 
{
1411
 
        return Vector_ass_item(self, GET_INT_FROM_POINTER(type), value);
1412
 
}
1413
 
 
1414
 
/* vector.length */
1415
 
static PyObject *Vector_getLength(VectorObject *self, void *type )
1416
 
{
1417
 
        double dot = 0.0f;
1418
 
        int i;
1419
 
        
1420
 
        if(!BaseMath_ReadCallback(self))
1421
 
                return NULL;
1422
 
        
1423
 
        for(i = 0; i < self->size; i++){
1424
 
                dot += (self->vec[i] * self->vec[i]);
1425
 
        }
1426
 
        return PyFloat_FromDouble(sqrt(dot));
1427
 
}
1428
 
 
1429
 
static int Vector_setLength(VectorObject *self, PyObject * value )
1430
 
{
1431
 
        double dot = 0.0f, param;
1432
 
        int i;
1433
 
        
1434
 
        if(!BaseMath_ReadCallback(self))
1435
 
                return -1;
1436
 
 
1437
 
        if((param=PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) {
1438
 
                PyErr_SetString(PyExc_TypeError, "length must be set to a number");
1439
 
                return -1;
1440
 
        }
1441
 
        
1442
 
        if (param < 0.0f) {
1443
 
                PyErr_SetString( PyExc_TypeError, "cannot set a vectors length to a negative value" );
1444
 
                return -1;
1445
 
        }
1446
 
        if (param == 0.0f) {
1447
 
                for(i = 0; i < self->size; i++){
1448
 
                        self->vec[i]= 0;
1449
 
                }
1450
 
                return 0;
1451
 
        }
1452
 
        
1453
 
        for(i = 0; i < self->size; i++){
1454
 
                dot += (self->vec[i] * self->vec[i]);
1455
 
        }
1456
 
 
1457
 
        if (!dot) /* cant sqrt zero */
1458
 
                return 0;
1459
 
        
1460
 
        dot = sqrt(dot);
1461
 
        
1462
 
        if (dot==param)
1463
 
                return 0;
1464
 
        
1465
 
        dot= dot/param;
1466
 
        
1467
 
        for(i = 0; i < self->size; i++){
1468
 
                self->vec[i]= self->vec[i] / (float)dot;
1469
 
        }
1470
 
        
1471
 
        BaseMath_WriteCallback(self); /* checked already */
1472
 
        
1473
 
        return 0;
1474
 
}
1475
 
 
1476
 
/* Get a new Vector according to the provided swizzle. This function has little
1477
 
   error checking, as we are in control of the inputs: the closure is set by us
1478
 
   in Vector_createSwizzleGetSeter. */
1479
 
static PyObject *Vector_getSwizzle(VectorObject *self, void *closure)
1480
 
{
1481
 
        size_t axis_to;
1482
 
        size_t axis_from;
1483
 
        float vec[MAX_DIMENSIONS];
1484
 
        unsigned int swizzleClosure;
1485
 
        
1486
 
        if(!BaseMath_ReadCallback(self))
1487
 
                return NULL;
1488
 
        
1489
 
        /* Unpack the axes from the closure into an array. */
1490
 
        axis_to = 0;
1491
 
        swizzleClosure = GET_INT_FROM_POINTER(closure);
1492
 
        while (swizzleClosure & SWIZZLE_VALID_AXIS)
1493
 
        {
1494
 
                axis_from = swizzleClosure & SWIZZLE_AXIS;
1495
 
                if(axis_from >= self->size) {
1496
 
                        PyErr_SetString(PyExc_AttributeError, "Error: vector does not have specified axis.");
1497
 
                        return NULL;
1498
 
                }
1499
 
 
1500
 
                vec[axis_to] = self->vec[axis_from];
1501
 
                swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
1502
 
                axis_to++;
1503
 
        }
1504
 
        
1505
 
        return newVectorObject(vec, axis_to, Py_NEW, Py_TYPE(self));
1506
 
}
1507
 
 
1508
 
/* Set the items of this vector using a swizzle.
1509
 
   - If value is a vector or list this operates like an array copy, except that
1510
 
         the destination is effectively re-ordered as defined by the swizzle. At
1511
 
         most min(len(source), len(dest)) values will be copied.
1512
 
   - If the value is scalar, it is copied to all axes listed in the swizzle.
1513
 
   - If an axis appears more than once in the swizzle, the final occurrence is
1514
 
         the one that determines its value.
1515
 
 
1516
 
   Returns 0 on success and -1 on failure. On failure, the vector will be
1517
 
   unchanged. */
1518
 
static int Vector_setSwizzle(VectorObject *self, PyObject * value, void *closure)
1519
 
{
1520
 
        size_t size_from;
1521
 
        float scalarVal;
1522
 
 
1523
 
        size_t axis_from;
1524
 
        size_t axis_to;
1525
 
 
1526
 
        unsigned int swizzleClosure;
1527
 
        
1528
 
        float tvec[MAX_DIMENSIONS];
1529
 
        float vec_assign[MAX_DIMENSIONS];
1530
 
        
1531
 
        if(!BaseMath_ReadCallback(self))
1532
 
                return -1;
1533
 
        
1534
 
        /* Check that the closure can be used with this vector: even 2D vectors have
1535
 
           swizzles defined for axes z and w, but they would be invalid. */
1536
 
        swizzleClosure = GET_INT_FROM_POINTER(closure);
1537
 
        axis_from= 0;
1538
 
        while (swizzleClosure & SWIZZLE_VALID_AXIS)
1539
 
        {
1540
 
                axis_to = swizzleClosure & SWIZZLE_AXIS;
1541
 
                if (axis_to >= self->size)
1542
 
                {
1543
 
                        PyErr_SetString(PyExc_AttributeError, "Error: vector does not have specified axis.\n");
1544
 
                        return -1;
1545
 
                }
1546
 
                swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
1547
 
                axis_from++;
1548
 
        }
1549
 
 
1550
 
        if (((scalarVal=PyFloat_AsDouble(value)) == -1 && PyErr_Occurred())==0) {
1551
 
                int i;
1552
 
                for(i=0; i < MAX_DIMENSIONS; i++)
1553
 
                        vec_assign[i]= scalarVal;
1554
 
 
1555
 
                size_from= axis_from;
1556
 
        }
1557
 
        else if((size_from=mathutils_array_parse(vec_assign, 2, 4, value, "mathutils.Vector.**** = swizzle assignment")) == -1) {
1558
 
                return -1;
1559
 
        }
1560
 
 
1561
 
        if(axis_from != size_from) {
1562
 
                PyErr_SetString(PyExc_AttributeError, "Error: vector size does not match swizzle.\n");
1563
 
                return -1;
1564
 
        }
1565
 
 
1566
 
        /* Copy vector contents onto swizzled axes. */
1567
 
        axis_from = 0;
1568
 
        swizzleClosure = GET_INT_FROM_POINTER(closure);
1569
 
        while (swizzleClosure & SWIZZLE_VALID_AXIS)
1570
 
        {
1571
 
                axis_to = swizzleClosure & SWIZZLE_AXIS;
1572
 
                tvec[axis_to] = vec_assign[axis_from];
1573
 
                swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
1574
 
                axis_from++;
1575
 
        }
1576
 
 
1577
 
        memcpy(self->vec, tvec, axis_from * sizeof(float));
1578
 
        /* continue with BaseMathObject_WriteCallback at the end */
1579
 
        
1580
 
        if(!BaseMath_WriteCallback(self))
1581
 
                return -1;
1582
 
        else
1583
 
                return 0;
1584
 
}
1585
 
 
1586
 
/*****************************************************************************/
1587
 
/* Python attributes get/set structure:                                      */
1588
 
/*****************************************************************************/
1589
 
static PyGetSetDef Vector_getseters[] = {
1590
 
        {"x", (getter)Vector_getAxis, (setter)Vector_setAxis, "Vector X axis. **type** float", (void *)0},
1591
 
        {"y", (getter)Vector_getAxis, (setter)Vector_setAxis, "Vector Y axis. **type** float", (void *)1},
1592
 
        {"z", (getter)Vector_getAxis, (setter)Vector_setAxis, "Vector Z axis (3D Vectors only). **type** float", (void *)2},
1593
 
        {"w", (getter)Vector_getAxis, (setter)Vector_setAxis, "Vector W axis (4D Vectors only). **type** float", (void *)3},
1594
 
        {"length", (getter)Vector_getLength, (setter)Vector_setLength, "Vector Length. **type** float", NULL},
1595
 
        {"magnitude", (getter)Vector_getLength, (setter)Vector_setLength, "Vector Length. **type** float", NULL},
1596
 
        {"is_wrapped", (getter)BaseMathObject_getWrapped, (setter)NULL, BaseMathObject_Wrapped_doc, NULL},
1597
 
        {"_owner", (getter)BaseMathObject_getOwner, (setter)NULL, BaseMathObject_Owner_doc, NULL},
1598
 
        
1599
 
        /* autogenerated swizzle attrs, see python script below */
1600
 
        {"xx",   (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 36
1601
 
        {"xxx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 292
1602
 
        {"xxxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2340
1603
 
        {"xxxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2852
1604
 
        {"xxxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3364
1605
 
        {"xxxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3876
1606
 
        {"xxy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 356
1607
 
        {"xxyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2404
1608
 
        {"xxyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2916
1609
 
        {"xxyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3428
1610
 
        {"xxyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3940
1611
 
        {"xxz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 420
1612
 
        {"xxzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2468
1613
 
        {"xxzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2980
1614
 
        {"xxzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3492
1615
 
        {"xxzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4004
1616
 
        {"xxw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 484
1617
 
        {"xxwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2532
1618
 
        {"xxwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3044
1619
 
        {"xxwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3556
1620
 
        {"xxww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4068
1621
 
        {"xy",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 44
1622
 
        {"xyx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 300
1623
 
        {"xyxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2348
1624
 
        {"xyxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2860
1625
 
        {"xyxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3372
1626
 
        {"xyxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3884
1627
 
        {"xyy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 364
1628
 
        {"xyyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2412
1629
 
        {"xyyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2924
1630
 
        {"xyyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3436
1631
 
        {"xyyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3948
1632
 
        {"xyz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 428
1633
 
        {"xyzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2476
1634
 
        {"xyzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2988
1635
 
        {"xyzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3500
1636
 
        {"xyzw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4012
1637
 
        {"xyw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 492
1638
 
        {"xywx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2540
1639
 
        {"xywy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3052
1640
 
        {"xywz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3564
1641
 
        {"xyww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4076
1642
 
        {"xz",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 52
1643
 
        {"xzx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 308
1644
 
        {"xzxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2356
1645
 
        {"xzxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2868
1646
 
        {"xzxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3380
1647
 
        {"xzxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3892
1648
 
        {"xzy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 372
1649
 
        {"xzyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2420
1650
 
        {"xzyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2932
1651
 
        {"xzyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3444
1652
 
        {"xzyw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3956
1653
 
        {"xzz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 436
1654
 
        {"xzzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2484
1655
 
        {"xzzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2996
1656
 
        {"xzzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3508
1657
 
        {"xzzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4020
1658
 
        {"xzw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 500
1659
 
        {"xzwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2548
1660
 
        {"xzwy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3060
1661
 
        {"xzwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3572
1662
 
        {"xzww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4084
1663
 
        {"xw",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 60
1664
 
        {"xwx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 316
1665
 
        {"xwxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2364
1666
 
        {"xwxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2876
1667
 
        {"xwxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3388
1668
 
        {"xwxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3900
1669
 
        {"xwy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 380
1670
 
        {"xwyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2428
1671
 
        {"xwyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2940
1672
 
        {"xwyz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3452
1673
 
        {"xwyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3964
1674
 
        {"xwz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 444
1675
 
        {"xwzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2492
1676
 
        {"xwzy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3004
1677
 
        {"xwzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3516
1678
 
        {"xwzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4028
1679
 
        {"xww",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 508
1680
 
        {"xwwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2556
1681
 
        {"xwwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3068
1682
 
        {"xwwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3580
1683
 
        {"xwww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((0|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4092
1684
 
        {"yx",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 37
1685
 
        {"yxx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 293
1686
 
        {"yxxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2341
1687
 
        {"yxxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2853
1688
 
        {"yxxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3365
1689
 
        {"yxxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3877
1690
 
        {"yxy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 357
1691
 
        {"yxyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2405
1692
 
        {"yxyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2917
1693
 
        {"yxyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3429
1694
 
        {"yxyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3941
1695
 
        {"yxz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 421
1696
 
        {"yxzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2469
1697
 
        {"yxzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2981
1698
 
        {"yxzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3493
1699
 
        {"yxzw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4005
1700
 
        {"yxw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 485
1701
 
        {"yxwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2533
1702
 
        {"yxwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3045
1703
 
        {"yxwz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3557
1704
 
        {"yxww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4069
1705
 
        {"yy",   (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 45
1706
 
        {"yyx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 301
1707
 
        {"yyxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2349
1708
 
        {"yyxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2861
1709
 
        {"yyxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3373
1710
 
        {"yyxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3885
1711
 
        {"yyy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 365
1712
 
        {"yyyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2413
1713
 
        {"yyyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2925
1714
 
        {"yyyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3437
1715
 
        {"yyyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3949
1716
 
        {"yyz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 429
1717
 
        {"yyzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2477
1718
 
        {"yyzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2989
1719
 
        {"yyzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3501
1720
 
        {"yyzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4013
1721
 
        {"yyw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 493
1722
 
        {"yywx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2541
1723
 
        {"yywy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3053
1724
 
        {"yywz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3565
1725
 
        {"yyww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4077
1726
 
        {"yz",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 53
1727
 
        {"yzx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 309
1728
 
        {"yzxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2357
1729
 
        {"yzxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2869
1730
 
        {"yzxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3381
1731
 
        {"yzxw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3893
1732
 
        {"yzy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 373
1733
 
        {"yzyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2421
1734
 
        {"yzyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2933
1735
 
        {"yzyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3445
1736
 
        {"yzyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3957
1737
 
        {"yzz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 437
1738
 
        {"yzzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2485
1739
 
        {"yzzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2997
1740
 
        {"yzzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3509
1741
 
        {"yzzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4021
1742
 
        {"yzw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 501
1743
 
        {"yzwx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2549
1744
 
        {"yzwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3061
1745
 
        {"yzwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3573
1746
 
        {"yzww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4085
1747
 
        {"yw",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 61
1748
 
        {"ywx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 317
1749
 
        {"ywxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2365
1750
 
        {"ywxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2877
1751
 
        {"ywxz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3389
1752
 
        {"ywxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3901
1753
 
        {"ywy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 381
1754
 
        {"ywyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2429
1755
 
        {"ywyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2941
1756
 
        {"ywyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3453
1757
 
        {"ywyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3965
1758
 
        {"ywz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 445
1759
 
        {"ywzx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2493
1760
 
        {"ywzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3005
1761
 
        {"ywzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3517
1762
 
        {"ywzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4029
1763
 
        {"yww",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 509
1764
 
        {"ywwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2557
1765
 
        {"ywwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3069
1766
 
        {"ywwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3581
1767
 
        {"ywww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((1|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4093
1768
 
        {"zx",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 38
1769
 
        {"zxx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 294
1770
 
        {"zxxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2342
1771
 
        {"zxxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2854
1772
 
        {"zxxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3366
1773
 
        {"zxxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3878
1774
 
        {"zxy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 358
1775
 
        {"zxyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2406
1776
 
        {"zxyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2918
1777
 
        {"zxyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3430
1778
 
        {"zxyw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3942
1779
 
        {"zxz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 422
1780
 
        {"zxzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2470
1781
 
        {"zxzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2982
1782
 
        {"zxzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3494
1783
 
        {"zxzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4006
1784
 
        {"zxw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 486
1785
 
        {"zxwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2534
1786
 
        {"zxwy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3046
1787
 
        {"zxwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3558
1788
 
        {"zxww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4070
1789
 
        {"zy",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 46
1790
 
        {"zyx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 302
1791
 
        {"zyxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2350
1792
 
        {"zyxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2862
1793
 
        {"zyxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3374
1794
 
        {"zyxw", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3886
1795
 
        {"zyy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 366
1796
 
        {"zyyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2414
1797
 
        {"zyyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2926
1798
 
        {"zyyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3438
1799
 
        {"zyyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3950
1800
 
        {"zyz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 430
1801
 
        {"zyzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2478
1802
 
        {"zyzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2990
1803
 
        {"zyzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3502
1804
 
        {"zyzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4014
1805
 
        {"zyw",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 494
1806
 
        {"zywx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2542
1807
 
        {"zywy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3054
1808
 
        {"zywz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3566
1809
 
        {"zyww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4078
1810
 
        {"zz",   (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 54
1811
 
        {"zzx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 310
1812
 
        {"zzxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2358
1813
 
        {"zzxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2870
1814
 
        {"zzxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3382
1815
 
        {"zzxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3894
1816
 
        {"zzy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 374
1817
 
        {"zzyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2422
1818
 
        {"zzyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2934
1819
 
        {"zzyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3446
1820
 
        {"zzyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3958
1821
 
        {"zzz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 438
1822
 
        {"zzzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2486
1823
 
        {"zzzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2998
1824
 
        {"zzzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3510
1825
 
        {"zzzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4022
1826
 
        {"zzw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 502
1827
 
        {"zzwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2550
1828
 
        {"zzwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3062
1829
 
        {"zzwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3574
1830
 
        {"zzww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4086
1831
 
        {"zw",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 62
1832
 
        {"zwx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 318
1833
 
        {"zwxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2366
1834
 
        {"zwxy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2878
1835
 
        {"zwxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3390
1836
 
        {"zwxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3902
1837
 
        {"zwy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 382
1838
 
        {"zwyx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2430
1839
 
        {"zwyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2942
1840
 
        {"zwyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3454
1841
 
        {"zwyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3966
1842
 
        {"zwz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 446
1843
 
        {"zwzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2494
1844
 
        {"zwzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3006
1845
 
        {"zwzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3518
1846
 
        {"zwzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4030
1847
 
        {"zww",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 510
1848
 
        {"zwwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2558
1849
 
        {"zwwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3070
1850
 
        {"zwwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3582
1851
 
        {"zwww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((2|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4094
1852
 
        {"wx",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 39
1853
 
        {"wxx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 295
1854
 
        {"wxxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2343
1855
 
        {"wxxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2855
1856
 
        {"wxxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3367
1857
 
        {"wxxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3879
1858
 
        {"wxy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 359
1859
 
        {"wxyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2407
1860
 
        {"wxyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2919
1861
 
        {"wxyz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3431
1862
 
        {"wxyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3943
1863
 
        {"wxz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 423
1864
 
        {"wxzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2471
1865
 
        {"wxzy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2983
1866
 
        {"wxzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3495
1867
 
        {"wxzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4007
1868
 
        {"wxw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 487
1869
 
        {"wxwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2535
1870
 
        {"wxwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3047
1871
 
        {"wxwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3559
1872
 
        {"wxww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4071
1873
 
        {"wy",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 47
1874
 
        {"wyx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 303
1875
 
        {"wyxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2351
1876
 
        {"wyxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2863
1877
 
        {"wyxz", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3375
1878
 
        {"wyxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3887
1879
 
        {"wyy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 367
1880
 
        {"wyyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2415
1881
 
        {"wyyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2927
1882
 
        {"wyyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3439
1883
 
        {"wyyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3951
1884
 
        {"wyz",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 431
1885
 
        {"wyzx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2479
1886
 
        {"wyzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2991
1887
 
        {"wyzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3503
1888
 
        {"wyzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4015
1889
 
        {"wyw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 495
1890
 
        {"wywx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2543
1891
 
        {"wywy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3055
1892
 
        {"wywz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3567
1893
 
        {"wyww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4079
1894
 
        {"wz",   (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 55
1895
 
        {"wzx",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 311
1896
 
        {"wzxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2359
1897
 
        {"wzxy", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2871
1898
 
        {"wzxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3383
1899
 
        {"wzxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3895
1900
 
        {"wzy",  (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 375
1901
 
        {"wzyx", (getter)Vector_getSwizzle, (setter)Vector_setSwizzle, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2423
1902
 
        {"wzyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2935
1903
 
        {"wzyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3447
1904
 
        {"wzyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3959
1905
 
        {"wzz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 439
1906
 
        {"wzzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2487
1907
 
        {"wzzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2999
1908
 
        {"wzzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3511
1909
 
        {"wzzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4023
1910
 
        {"wzw",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 503
1911
 
        {"wzwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2551
1912
 
        {"wzwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3063
1913
 
        {"wzwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3575
1914
 
        {"wzww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4087
1915
 
        {"ww",   (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS)))}, // 63
1916
 
        {"wwx",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 319
1917
 
        {"wwxx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2367
1918
 
        {"wwxy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2879
1919
 
        {"wwxz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3391
1920
 
        {"wwxw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3903
1921
 
        {"wwy",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 383
1922
 
        {"wwyx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2431
1923
 
        {"wwyy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2943
1924
 
        {"wwyz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3455
1925
 
        {"wwyw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3967
1926
 
        {"wwz",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 447
1927
 
        {"wwzx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2495
1928
 
        {"wwzy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3007
1929
 
        {"wwzz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3519
1930
 
        {"wwzw", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4031
1931
 
        {"www",  (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2))))}, // 511
1932
 
        {"wwwx", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((0|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 2559
1933
 
        {"wwwy", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((1|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3071
1934
 
        {"wwwz", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((2|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 3583
1935
 
        {"wwww", (getter)Vector_getSwizzle, (setter)NULL, NULL, SET_INT_IN_POINTER(((3|SWIZZLE_VALID_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*2)) | ((3|SWIZZLE_VALID_AXIS)<<(SWIZZLE_BITS_PER_AXIS*3)))  )}, // 4095
1936
 
        {NULL,NULL,NULL,NULL,NULL}  /* Sentinel */
1937
 
};
1938
 
 
1939
 
/* Python script used to make swizzle array */
1940
 
/*
1941
 
SWIZZLE_BITS_PER_AXIS = 3
1942
 
SWIZZLE_VALID_AXIS = 0x4
1943
 
 
1944
 
axis_dict = {}
1945
 
axis_pos = {'x':0, 'y':1, 'z':2, 'w':3}
1946
 
axises = 'xyzw'
1947
 
while len(axises) >= 2:
1948
 
        
1949
 
        for axis_0 in axises:
1950
 
                axis_0_pos = axis_pos[axis_0]
1951
 
                for axis_1 in axises:
1952
 
                        axis_1_pos = axis_pos[axis_1]
1953
 
                        axis_dict[axis_0+axis_1] = '((%s|SWIZZLE_VALID_AXIS) | ((%s|SWIZZLE_VALID_AXIS)<<SWIZZLE_BITS_PER_AXIS))' % (axis_0_pos, axis_1_pos)
1954
 
                        if len(axises)>2:
1955
 
                                for axis_2 in axises:
1956
 
                                        axis_2_pos = axis_pos[axis_2]
1957
 
                                        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)
1958
 
                                        if len(axises)>3:
1959
 
                                                for axis_3 in axises:
1960
 
                                                        axis_3_pos = axis_pos[axis_3]
1961
 
                                                        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)
1962
 
        
1963
 
        axises = axises[:-1]
1964
 
 
1965
 
 
1966
 
items = axis_dict.items()
1967
 
items.sort(key = lambda a: a[0].replace('x', '0').replace('y', '1').replace('z', '2').replace('w', '3'))
1968
 
 
1969
 
unique = set()
1970
 
for key, val in items:
1971
 
        num = eval(val)
1972
 
        set_str = 'Vector_setSwizzle' if (len(set(key)) == len(key)) else 'NULL'
1973
 
        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)
1974
 
        unique.add(num)
1975
 
 
1976
 
if len(unique) != len(items):
1977
 
        print "ERROR"
1978
 
*/
1979
 
 
1980
 
//-----------------row_vector_multiplication (internal)-----------
1981
 
//ROW VECTOR Multiplication - Vector X Matrix
1982
 
//[x][y][z] *  [1][4][7]
1983
 
//             [2][5][8]
1984
 
//             [3][6][9]
1985
 
//vector/matrix multiplication IS NOT COMMUTATIVE!!!!
1986
 
static PyObject *row_vector_multiplication(VectorObject* vec, MatrixObject * mat)
1987
 
{
1988
 
        float vecNew[4], vecCopy[4];
1989
 
        double dot = 0.0f;
1990
 
        int x, y, z = 0, vec_size = vec->size;
1991
 
 
1992
 
        if(mat->colSize != vec_size){
1993
 
                if(mat->colSize == 4 && vec_size != 3){
1994
 
                        PyErr_SetString(PyExc_AttributeError, "vector * matrix: matrix column size and the vector size must be the same");
1995
 
                        return NULL;
1996
 
                }else{
1997
 
                        vecCopy[3] = 1.0f;
1998
 
                }
1999
 
        }
2000
 
        
2001
 
        if(!BaseMath_ReadCallback(vec) || !BaseMath_ReadCallback(mat))
2002
 
                return NULL;
2003
 
        
2004
 
        for(x = 0; x < vec_size; x++){
2005
 
                vecCopy[x] = vec->vec[x];
2006
 
        }
2007
 
        vecNew[3] = 1.0f;
2008
 
        //muliplication
2009
 
        for(x = 0; x < mat->rowSize; x++) {
2010
 
                for(y = 0; y < mat->colSize; y++) {
2011
 
                        dot += mat->matrix[x][y] * vecCopy[y];
2012
 
                }
2013
 
                vecNew[z++] = (float)dot;
2014
 
                dot = 0.0f;
2015
 
        }
2016
 
        return newVectorObject(vecNew, vec_size, Py_NEW, NULL);
2017
 
}
2018
 
 
2019
 
/*----------------------------Vector.negate() -------------------- */
2020
 
static char Vector_Negate_doc[] =
2021
 
".. method:: negate()\n"
2022
 
"\n"
2023
 
"   Set all values to their negative.\n"
2024
 
"\n"
2025
 
"   :return: an instance of itself\n"
2026
 
"   :rtype: :class:`Vector`\n";
2027
 
 
2028
 
static PyObject *Vector_Negate(VectorObject *self)
2029
 
{
2030
 
        int i;
2031
 
        if(!BaseMath_ReadCallback(self))
2032
 
                return NULL;
2033
 
        
2034
 
        for(i = 0; i < self->size; i++)
2035
 
                self->vec[i] = -(self->vec[i]);
2036
 
        
2037
 
        BaseMath_WriteCallback(self); // already checked for error
2038
 
        
2039
 
        Py_INCREF(self);
2040
 
        return (PyObject*)self;
2041
 
}
2042
 
 
2043
 
static struct PyMethodDef Vector_methods[] = {
2044
 
        {"zero", (PyCFunction) Vector_Zero, METH_NOARGS, Vector_Zero_doc},
2045
 
        {"normalize", (PyCFunction) Vector_Normalize, METH_NOARGS, Vector_Normalize_doc},
2046
 
        {"negate", (PyCFunction) Vector_Negate, METH_NOARGS, Vector_Negate_doc},
2047
 
        {"resize2D", (PyCFunction) Vector_Resize2D, METH_NOARGS, Vector_Resize2D_doc},
2048
 
        {"resize3D", (PyCFunction) Vector_Resize3D, METH_NOARGS, Vector_Resize3D_doc},
2049
 
        {"resize4D", (PyCFunction) Vector_Resize4D, METH_NOARGS, Vector_Resize4D_doc},
2050
 
        {"to_tuple", (PyCFunction) Vector_ToTuple, METH_VARARGS, Vector_ToTuple_doc},
2051
 
        {"to_track_quat", ( PyCFunction ) Vector_ToTrackQuat, METH_VARARGS, Vector_ToTrackQuat_doc},
2052
 
        {"reflect", ( PyCFunction ) Vector_Reflect, METH_O, Vector_Reflect_doc},
2053
 
        {"cross", ( PyCFunction ) Vector_Cross, METH_O, Vector_Cross_doc},
2054
 
        {"dot", ( PyCFunction ) Vector_Dot, METH_O, Vector_Dot_doc},
2055
 
        {"angle", ( PyCFunction ) Vector_angle, METH_VARARGS, Vector_angle_doc},
2056
 
        {"difference", ( PyCFunction ) Vector_Difference, METH_O, Vector_Difference_doc},
2057
 
        {"project", ( PyCFunction ) Vector_Project, METH_O, Vector_Project_doc},
2058
 
        {"lerp", ( PyCFunction ) Vector_Lerp, METH_VARARGS, Vector_Lerp_doc},
2059
 
        {"copy", (PyCFunction) Vector_copy, METH_NOARGS, Vector_copy_doc},
2060
 
        {"__copy__", (PyCFunction) Vector_copy, METH_NOARGS, NULL},
2061
 
        {NULL, NULL, 0, NULL}
2062
 
};
2063
 
 
2064
 
 
2065
 
/* Note
2066
 
 Py_TPFLAGS_CHECKTYPES allows us to avoid casting all types to Vector when coercing
2067
 
 but this means for eg that 
2068
 
 vec*mat and mat*vec both get sent to Vector_mul and it neesd to sort out the order
2069
 
*/
2070
 
 
2071
 
static char vector_doc[] =
2072
 
"This object gives access to Vectors in Blender.";
2073
 
 
2074
 
PyTypeObject vector_Type = {
2075
 
        PyVarObject_HEAD_INIT(NULL, 0)
2076
 
        /*  For printing, in format "<module>.<name>" */
2077
 
        "vector",             /* char *tp_name; */
2078
 
        sizeof(VectorObject),         /* int tp_basicsize; */
2079
 
        0,                          /* tp_itemsize;  For allocation */
2080
 
 
2081
 
        /* Methods to implement standard operations */
2082
 
 
2083
 
        ( destructor ) BaseMathObject_dealloc,/* destructor tp_dealloc; */
2084
 
        NULL,                       /* printfunc tp_print; */
2085
 
        NULL,                       /* getattrfunc tp_getattr; */
2086
 
        NULL,                       /* setattrfunc tp_setattr; */
2087
 
        NULL,   /* cmpfunc tp_compare; */
2088
 
        ( reprfunc ) Vector_repr,     /* reprfunc tp_repr; */
2089
 
 
2090
 
        /* Method suites for standard classes */
2091
 
 
2092
 
        &Vector_NumMethods,                       /* PyNumberMethods *tp_as_number; */
2093
 
        &Vector_SeqMethods,                       /* PySequenceMethods *tp_as_sequence; */
2094
 
        &Vector_AsMapping,                       /* PyMappingMethods *tp_as_mapping; */
2095
 
 
2096
 
        /* More standard operations (here for binary compatibility) */
2097
 
 
2098
 
        NULL,                       /* hashfunc tp_hash; */
2099
 
        NULL,                       /* ternaryfunc tp_call; */
2100
 
        NULL,                       /* reprfunc tp_str; */
2101
 
        NULL,                       /* getattrofunc tp_getattro; */
2102
 
        NULL,                       /* setattrofunc tp_setattro; */
2103
 
 
2104
 
        /* Functions to access object as input/output buffer */
2105
 
        NULL,                       /* PyBufferProcs *tp_as_buffer; */
2106
 
 
2107
 
  /*** Flags to define presence of optional/expanded features ***/
2108
 
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2109
 
        vector_doc,                       /*  char *tp_doc;  Documentation string */
2110
 
  /*** Assigned meaning in release 2.0 ***/
2111
 
        /* call function for all accessible objects */
2112
 
        NULL,                       /* traverseproc tp_traverse; */
2113
 
 
2114
 
        /* delete references to contained objects */
2115
 
        NULL,                       /* inquiry tp_clear; */
2116
 
 
2117
 
  /***  Assigned meaning in release 2.1 ***/
2118
 
  /*** rich comparisons ***/
2119
 
        (richcmpfunc)Vector_richcmpr,                       /* richcmpfunc tp_richcompare; */
2120
 
 
2121
 
  /***  weak reference enabler ***/
2122
 
        0,                          /* long tp_weaklistoffset; */
2123
 
 
2124
 
  /*** Added in release 2.2 ***/
2125
 
        /*   Iterators */
2126
 
        NULL,                       /* getiterfunc tp_iter; */
2127
 
        NULL,                       /* iternextfunc tp_iternext; */
2128
 
 
2129
 
  /*** Attribute descriptor and subclassing stuff ***/
2130
 
        Vector_methods,           /* struct PyMethodDef *tp_methods; */
2131
 
        NULL,                       /* struct PyMemberDef *tp_members; */
2132
 
        Vector_getseters,           /* struct PyGetSetDef *tp_getset; */
2133
 
        NULL,                       /* struct _typeobject *tp_base; */
2134
 
        NULL,                       /* PyObject *tp_dict; */
2135
 
        NULL,                       /* descrgetfunc tp_descr_get; */
2136
 
        NULL,                       /* descrsetfunc tp_descr_set; */
2137
 
        0,                          /* long tp_dictoffset; */
2138
 
        NULL,                       /* initproc tp_init; */
2139
 
        NULL,                       /* allocfunc tp_alloc; */
2140
 
        Vector_new,                 /* newfunc tp_new; */
2141
 
        /*  Low-level free-memory routine */
2142
 
        NULL,                       /* freefunc tp_free;  */
2143
 
        /* For PyObject_IS_GC */
2144
 
        NULL,                       /* inquiry tp_is_gc;  */
2145
 
        NULL,                       /* PyObject *tp_bases; */
2146
 
        /* method resolution order */
2147
 
        NULL,                       /* PyObject *tp_mro;  */
2148
 
        NULL,                       /* PyObject *tp_cache; */
2149
 
        NULL,                       /* PyObject *tp_subclasses; */
2150
 
        NULL,                       /* PyObject *tp_weaklist; */
2151
 
        NULL
2152
 
};
2153
 
 
2154
 
/*------------------------newVectorObject (internal)-------------
2155
 
  creates a new vector object
2156
 
  pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
2157
 
 (i.e. it was allocated elsewhere by MEM_mallocN())
2158
 
  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
2159
 
 (i.e. it must be created here with PyMEM_malloc())*/
2160
 
PyObject *newVectorObject(float *vec, int size, int type, PyTypeObject *base_type)
2161
 
{
2162
 
        int i;
2163
 
        VectorObject *self;
2164
 
 
2165
 
        if(size > 4 || size < 2)
2166
 
                return NULL;
2167
 
 
2168
 
        if(base_type)   self = (VectorObject *)base_type->tp_alloc(base_type, 0);
2169
 
        else                    self = PyObject_NEW(VectorObject, &vector_Type);
2170
 
 
2171
 
        self->size = size;
2172
 
        
2173
 
        /* init callbacks as NULL */
2174
 
        self->cb_user= NULL;
2175
 
        self->cb_type= self->cb_subtype= 0;
2176
 
 
2177
 
        if(type == Py_WRAP) {
2178
 
                self->vec = vec;
2179
 
                self->wrapped = Py_WRAP;
2180
 
        } else if (type == Py_NEW) {
2181
 
                self->vec = PyMem_Malloc(size * sizeof(float));
2182
 
                if(!vec) { /*new empty*/
2183
 
                        for(i = 0; i < size; i++){
2184
 
                                self->vec[i] = 0.0f;
2185
 
                        }
2186
 
                        if(size == 4)  /* do the homogenous thing */
2187
 
                                self->vec[3] = 1.0f;
2188
 
                }else{
2189
 
                        for(i = 0; i < size; i++){
2190
 
                                self->vec[i] = vec[i];
2191
 
                        }
2192
 
                }
2193
 
                self->wrapped = Py_NEW;
2194
 
        }else{ /*bad type*/
2195
 
                return NULL;
2196
 
        }
2197
 
        return (PyObject *) self;
2198
 
}
2199
 
 
2200
 
PyObject *newVectorObject_cb(PyObject *cb_user, int size, int cb_type, int cb_subtype)
2201
 
{
2202
 
        float dummy[4] = {0.0, 0.0, 0.0, 0.0}; /* dummy init vector, callbacks will be used on access */
2203
 
        VectorObject *self= (VectorObject *)newVectorObject(dummy, size, Py_NEW, NULL);
2204
 
        if(self) {
2205
 
                Py_INCREF(cb_user);
2206
 
                self->cb_user=                  cb_user;
2207
 
                self->cb_type=                  (unsigned char)cb_type;
2208
 
                self->cb_subtype=               (unsigned char)cb_subtype;
2209
 
        }
2210
 
        
2211
 
        return (PyObject *)self;
2212
 
}