← Back to branch summary

~mir-team/mir/in-process-egl+input-conglomeration

« back to all changes in this revision

Viewing changes to 3rd_party/glm/glm/core/type_vec1.inl

Merged trunk and fixed issues

Show diffs side-by-side

added added

removed removed

Lines of Context:
3rd_party/glm/glm/core/type_vec1.inl
1
 
///////////////////////////////////////////////////////////////////////////////////
2
 
/// OpenGL Mathematics (glm.g-truc.net)
3
 
///
4
 
/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
5
 
/// Permission is hereby granted, free of charge, to any person obtaining a copy
6
 
/// of this software and associated documentation files (the "Software"), to deal
7
 
/// in the Software without restriction, including without limitation the rights
8
 
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
 
/// copies of the Software, and to permit persons to whom the Software is
10
 
/// furnished to do so, subject to the following conditions:
11
 
/// 
12
 
/// The above copyright notice and this permission notice shall be included in
13
 
/// all copies or substantial portions of the Software.
14
 
/// 
15
 
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
 
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
 
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
 
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
 
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
 
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21
 
/// THE SOFTWARE.
22
 
///
23
 
/// @ref core
24
 
/// @file glm/core/type_vec1.inl
25
 
/// @date 2008-08-25 / 2011-06-15
26
 
/// @author Christophe Riccio
27
 
///////////////////////////////////////////////////////////////////////////////////
28
 
 
29
 
namespace glm{
30
 
namespace detail
31
 
{
32
 
        template <typename T>
33
 
        GLM_FUNC_QUALIFIER typename tvec1<T>::size_type tvec1<T>::length() const
34
 
        {
35
 
                return 1;
36
 
        }
37
 
 
38
 
        //////////////////////////////////////
39
 
        // Accesses
40
 
 
41
 
        template <typename T>
42
 
        GLM_FUNC_QUALIFIER typename tvec1<T>::value_type & tvec1<T>::operator[]
43
 
        (
44
 
                size_type i
45
 
        )
46
 
        {
47
 
                assert(i < this->length());
48
 
                return (&x)[i];
49
 
        }
50
 
 
51
 
        template <typename T>
52
 
        GLM_FUNC_QUALIFIER typename tvec1<T>::value_type const & tvec1<T>::operator[]
53
 
        (
54
 
                size_type i
55
 
        ) const
56
 
        {
57
 
                assert(i < this->length());
58
 
                return (&x)[i];
59
 
        }
60
 
 
61
 
        //////////////////////////////////////
62
 
        // Implicit basic constructors
63
 
 
64
 
        template <typename T>
65
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1() :
66
 
                x(value_type(0))
67
 
        {}
68
 
 
69
 
        template <typename T>
70
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1
71
 
        (
72
 
                ctor
73
 
        )
74
 
        {}
75
 
 
76
 
        template <typename T>
77
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1
78
 
        (
79
 
                tvec1<T> const & v
80
 
        ) :
81
 
                x(v.x)
82
 
        {}
83
 
 
84
 
        //////////////////////////////////////
85
 
        // Explicit basic constructors
86
 
 
87
 
        template <typename T>
88
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1
89
 
        (
90
 
                value_type const & s
91
 
        ) :
92
 
                x(s)
93
 
        {}
94
 
 
95
 
        //////////////////////////////////////
96
 
        // Swizzle constructors
97
 
 
98
 
        template <typename T>
99
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1
100
 
        (
101
 
                tref1<T> const & r
102
 
        ) :
103
 
                x(r.x)
104
 
        {}
105
 
 
106
 
        //////////////////////////////////////
107
 
        // Convertion scalar constructors
108
 
                
109
 
        template <typename T>
110
 
        template <typename U> 
111
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1
112
 
        (
113
 
                U const & s
114
 
        ) :
115
 
                x(value_type(s))
116
 
        {}
117
 
 
118
 
        //////////////////////////////////////
119
 
        // Convertion vector constructors
120
 
 
121
 
        template <typename T>
122
 
        template <typename U> 
123
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1
124
 
        (
125
 
                tvec2<U> const & v
126
 
        ) :
127
 
                x(value_type(v.x))
128
 
        {}
129
 
 
130
 
        template <typename T>
131
 
        template <typename U> 
132
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1
133
 
        (
134
 
                tvec3<U> const & v
135
 
        ) :
136
 
                x(value_type(v.x))
137
 
        {}
138
 
 
139
 
        template <typename T>
140
 
        template <typename U> 
141
 
        GLM_FUNC_QUALIFIER tvec1<T>::tvec1
142
 
        (
143
 
                tvec4<U> const & v
144
 
        ) :
145
 
                x(value_type(v.x))
146
 
        {}
147
 
 
148
 
        //////////////////////////////////////
149
 
        // Unary arithmetic operators
150
 
 
151
 
        template <typename T>
152
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
153
 
        (
154
 
                tvec1<T> const & v
155
 
        )
156
 
        {
157
 
                this->x = v.x;
158
 
                return *this;
159
 
        }
160
 
 
161
 
        template <typename T>
162
 
        template <typename U> 
163
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
164
 
        (
165
 
                tvec1<U> const & v
166
 
        )
167
 
        {
168
 
                this->x = T(v.x);
169
 
                return *this;
170
 
        }
171
 
 
172
 
        template <typename T>
173
 
        template <typename U> 
174
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
175
 
        (
176
 
                U const & s
177
 
        )
178
 
        {
179
 
                this->x += T(s);
180
 
                return *this;
181
 
        }
182
 
 
183
 
        template <typename T>
184
 
        template <typename U> 
185
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
186
 
        (
187
 
                tvec1<U> const & v
188
 
        )
189
 
        {
190
 
                this->x += T(v.x);
191
 
                return *this;
192
 
        }
193
 
 
194
 
        template <typename T>
195
 
        template <typename U> 
196
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
197
 
        (
198
 
                U const & s
199
 
        )
200
 
        {
201
 
                this->x -= T(s);
202
 
                return *this;
203
 
        }
204
 
 
205
 
        template <typename T>
206
 
        template <typename U> 
207
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
208
 
        (
209
 
                tvec1<U> const & v
210
 
        )
211
 
        {
212
 
                this->x -= T(v.x);
213
 
                return *this;
214
 
        }
215
 
 
216
 
        template <typename T>
217
 
        template <typename U> 
218
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
219
 
        (
220
 
                U const & s
221
 
        )
222
 
        {
223
 
                this->x *= T(s);
224
 
                return *this;
225
 
        }
226
 
 
227
 
        template <typename T>
228
 
        template <typename U> 
229
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
230
 
        (       
231
 
                tvec1<U> const & v
232
 
        )
233
 
        {
234
 
                this->x *= T(v.x);
235
 
                return *this;
236
 
        }
237
 
 
238
 
        template <typename T>
239
 
        template <typename U> 
240
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
241
 
        (
242
 
                U const & s
243
 
        )
244
 
        {
245
 
                this->x /= T(s);
246
 
                return *this;
247
 
        }
248
 
 
249
 
        template <typename T>
250
 
        template <typename U> 
251
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
252
 
        (
253
 
                tvec1<U> const & v
254
 
        )
255
 
        {
256
 
                this->x /= T(v.x);
257
 
                return *this;
258
 
        }
259
 
 
260
 
        template <typename T>
261
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator++()
262
 
        {
263
 
                ++this->x;
264
 
                return *this;
265
 
        }
266
 
 
267
 
        template <typename T>
268
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator--()
269
 
        {
270
 
                --this->x;
271
 
                return *this;
272
 
        }
273
 
 
274
 
        //////////////////////////////////////
275
 
        // Boolean operators
276
 
 
277
 
        template <typename T> 
278
 
        GLM_FUNC_QUALIFIER bool operator==
279
 
        (
280
 
                tvec1<T> const & v1, 
281
 
                tvec1<T> const & v2
282
 
        )
283
 
        {
284
 
                return (v1.x == v2.x);
285
 
        }
286
 
 
287
 
        template <typename T> 
288
 
        GLM_FUNC_QUALIFIER bool operator!=
289
 
        (
290
 
                tvec1<T> const & v1, 
291
 
                tvec1<T> const & v2
292
 
        )
293
 
        {
294
 
                return (v1.x != v2.x);
295
 
        }
296
 
 
297
 
        //////////////////////////////////////
298
 
        // Unary bit operators
299
 
 
300
 
        template <typename T>
301
 
        template <typename U> 
302
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
303
 
        (
304
 
                U const & s
305
 
        )
306
 
        {
307
 
                this->x %= T(s);
308
 
                return *this;
309
 
        }
310
 
 
311
 
        template <typename T>
312
 
        template <typename U> 
313
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
314
 
        (
315
 
                tvec1<U> const & v
316
 
        )
317
 
        {
318
 
                this->x %= T(v.x);
319
 
                return *this;
320
 
        }
321
 
 
322
 
        template <typename T>
323
 
        template <typename U> 
324
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
325
 
        (
326
 
                U const & s
327
 
        )
328
 
        {
329
 
                this->x &= T(s);
330
 
                return *this;
331
 
        }
332
 
 
333
 
        template <typename T>
334
 
        template <typename U> 
335
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
336
 
        (
337
 
                tvec1<U> const & v
338
 
        )
339
 
        {
340
 
                this->x &= T(v.x);
341
 
                return *this;
342
 
        }
343
 
 
344
 
        template <typename T>
345
 
        template <typename U> 
346
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
347
 
        (
348
 
                U const & s
349
 
        )
350
 
        {
351
 
                this->x |= T(s);
352
 
                return *this;
353
 
        }
354
 
 
355
 
        template <typename T>
356
 
        template <typename U> 
357
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
358
 
        (
359
 
                tvec1<U> const & v
360
 
        )
361
 
        {
362
 
                this->x |= U(v.x);
363
 
                return *this;
364
 
        }
365
 
 
366
 
        template <typename T>
367
 
        template <typename U> 
368
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
369
 
        (
370
 
                U const & s
371
 
        )
372
 
        {
373
 
                this->x ^= T(s);
374
 
                return *this;
375
 
        }
376
 
 
377
 
        template <typename T>
378
 
        template <typename U> 
379
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
380
 
        (
381
 
                tvec1<U> const & v
382
 
        )
383
 
        {
384
 
                this->x ^= T(v.x);
385
 
                return *this;
386
 
        }
387
 
 
388
 
        template <typename T>
389
 
        template <typename U> 
390
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
391
 
        (
392
 
                U const & s
393
 
        )
394
 
        {
395
 
                this->x <<= T(s);
396
 
                return *this;
397
 
        }
398
 
 
399
 
        template <typename T>
400
 
        template <typename U> 
401
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
402
 
        (
403
 
                tvec1<U> const & v
404
 
        )
405
 
        {
406
 
                this->x <<= T(v.x);
407
 
                return *this;
408
 
        }
409
 
 
410
 
        template <typename T>
411
 
        template <typename U> 
412
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
413
 
        (
414
 
                U const & s
415
 
        )
416
 
        {
417
 
                this->x >>= T(s);
418
 
                return *this;
419
 
        }
420
 
 
421
 
        template <typename T>
422
 
        template <typename U> 
423
 
        GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
424
 
        (
425
 
                tvec1<U> const & v
426
 
        )
427
 
        {
428
 
                this->x >>= T(v.x);
429
 
                return *this;
430
 
        }
431
 
 
432
 
        //////////////////////////////////////
433
 
        // Swizzle operators
434
 
 
435
 
        template <typename T>
436
 
        GLM_FUNC_QUALIFIER T 
437
 
        tvec1<T>::swizzle(comp x) const
438
 
        {
439
 
                return (*this)[x];
440
 
        }
441
 
 
442
 
        template <typename T>
443
 
        GLM_FUNC_QUALIFIER tvec2<T> 
444
 
        tvec1<T>::swizzle
445
 
        (
446
 
                comp x, 
447
 
                comp y
448
 
        ) const
449
 
        {
450
 
                return tvec2<T>(
451
 
                        (*this)[x],
452
 
                        (*this)[y]);
453
 
        }
454
 
 
455
 
        template <typename T>
456
 
        GLM_FUNC_QUALIFIER tvec3<T> 
457
 
        tvec1<T>::swizzle
458
 
        (
459
 
                comp x, 
460
 
                comp y, 
461
 
                comp z
462
 
        ) const
463
 
        {
464
 
                return tvec3<T>(
465
 
                        (*this)[x],
466
 
                        (*this)[y],
467
 
                        (*this)[z]);
468
 
        }
469
 
 
470
 
        template <typename T>
471
 
        GLM_FUNC_QUALIFIER tvec4<T> 
472
 
        tvec1<T>::swizzle
473
 
        (
474
 
                comp x, 
475
 
                comp y, 
476
 
                comp z, 
477
 
                comp w
478
 
        ) const
479
 
        {
480
 
                return tvec4<T>(
481
 
                        (*this)[x],
482
 
                        (*this)[y],
483
 
                        (*this)[z],
484
 
                        (*this)[w]);
485
 
        }
486
 
 
487
 
        template <typename T>
488
 
        GLM_FUNC_QUALIFIER tref1<T> 
489
 
        tvec1<T>::swizzle
490
 
        (
491
 
                comp x
492
 
        )
493
 
        {
494
 
                return tref1<T>(
495
 
                        (*this)[x]);
496
 
        }
497
 
 
498
 
        //////////////////////////////////////
499
 
        // Binary arithmetic operators
500
 
 
501
 
        template <typename T> 
502
 
        GLM_FUNC_QUALIFIER tvec1<T> operator+ 
503
 
        (
504
 
                tvec1<T> const & v, 
505
 
                typename tvec1<T>::value_type const & s
506
 
        )
507
 
        {
508
 
                return tvec1<T>(
509
 
                        v.x + s);
510
 
        }
511
 
 
512
 
        template <typename T> 
513
 
        GLM_FUNC_QUALIFIER tvec1<T> operator+ 
514
 
        (
515
 
                typename tvec1<T>::value_type const & s, 
516
 
                tvec1<T> const & v
517
 
        )
518
 
        {
519
 
                return tvec1<T>(
520
 
                        s + v.x);
521
 
        }
522
 
 
523
 
        template <typename T> 
524
 
        GLM_FUNC_QUALIFIER tvec1<T> operator+ 
525
 
        (
526
 
                tvec1<T> const & v1, 
527
 
                tvec1<T> const & v2
528
 
        )
529
 
        {
530
 
                return tvec1<T>(
531
 
                        v1.x + v2.x);
532
 
        }
533
 
 
534
 
        //operator-
535
 
        template <typename T> 
536
 
        GLM_FUNC_QUALIFIER tvec1<T> operator- 
537
 
        (
538
 
                tvec1<T> const & v, 
539
 
                typename tvec1<T>::value_type const & s
540
 
        )
541
 
        {
542
 
                return tvec1<T>(
543
 
                        v.x - s);
544
 
        }
545
 
 
546
 
        template <typename T> 
547
 
        GLM_FUNC_QUALIFIER tvec1<T> operator- 
548
 
        (
549
 
                typename tvec1<T>::value_type const & s, 
550
 
                tvec1<T> const & v
551
 
        )
552
 
        {
553
 
                return tvec1<T>(
554
 
                        s - v.x);
555
 
        }
556
 
 
557
 
        template <typename T> 
558
 
        GLM_FUNC_QUALIFIER tvec1<T> operator- 
559
 
        (
560
 
                tvec1<T> const & v1, 
561
 
                tvec1<T> const & v2
562
 
        )
563
 
        {
564
 
                return tvec1<T>(
565
 
                        v1.x - v2.x);
566
 
        }
567
 
 
568
 
        //operator*
569
 
        template <typename T> 
570
 
        GLM_FUNC_QUALIFIER tvec1<T> operator* 
571
 
        (
572
 
                tvec1<T> const & v, 
573
 
                typename tvec1<T>::value_type const & s
574
 
        )
575
 
        {
576
 
                return tvec1<T>(
577
 
                        v.x * s);
578
 
        }
579
 
 
580
 
        template <typename T> 
581
 
        GLM_FUNC_QUALIFIER tvec1<T> operator* 
582
 
        (
583
 
                typename tvec1<T>::value_type const & s, 
584
 
                tvec1<T> const & v
585
 
        )
586
 
        {
587
 
                return tvec1<T>(
588
 
                        s * v.x);
589
 
        }
590
 
 
591
 
        template <typename T> 
592
 
        GLM_FUNC_QUALIFIER tvec1<T> operator*
593
 
        (
594
 
                tvec1<T> const & v1, 
595
 
                tvec1<T> const & v2
596
 
        )
597
 
        {
598
 
                return tvec1<T>(
599
 
                        v1.x * v2.x);
600
 
        }
601
 
 
602
 
        //operator/
603
 
        template <typename T> 
604
 
        GLM_FUNC_QUALIFIER tvec1<T> operator/ 
605
 
        (
606
 
                tvec1<T> const & v, 
607
 
                typename tvec1<T>::value_type const & s
608
 
        )
609
 
        {
610
 
                return tvec1<T>(
611
 
                        v.x / s);
612
 
        }
613
 
 
614
 
        template <typename T> 
615
 
        GLM_FUNC_QUALIFIER tvec1<T> operator/ 
616
 
        (
617
 
                typename tvec1<T>::value_type const & s, 
618
 
                tvec1<T> const & v
619
 
        )
620
 
        {
621
 
                return tvec1<T>(
622
 
                        s / v.x);
623
 
        }
624
 
 
625
 
        template <typename T> 
626
 
        GLM_FUNC_QUALIFIER tvec1<T> operator/ 
627
 
        (
628
 
                tvec1<T> const & v1, 
629
 
                tvec1<T> const & v2
630
 
        )
631
 
        {
632
 
                return tvec1<T>(
633
 
                        v1.x / v2.x);
634
 
        }
635
 
 
636
 
        // Unary constant operators
637
 
        template <typename T> 
638
 
        GLM_FUNC_QUALIFIER tvec1<T> operator- 
639
 
        (
640
 
                tvec1<T> const & v
641
 
        )
642
 
        {
643
 
                return tvec1<T>(
644
 
                        -v.x);
645
 
        }
646
 
 
647
 
        template <typename T> 
648
 
        GLM_FUNC_QUALIFIER tvec1<T> operator++ 
649
 
        (
650
 
                tvec1<T> const & v, 
651
 
                int
652
 
        )
653
 
        {
654
 
                return tvec1<T>(
655
 
                        v.x + T(1));
656
 
        }
657
 
 
658
 
        template <typename T> 
659
 
        GLM_FUNC_QUALIFIER tvec1<T> operator-- 
660
 
        (
661
 
                tvec1<T> const & v, 
662
 
                int
663
 
        )
664
 
        {
665
 
                return tvec1<T>(
666
 
                        v.x - T(1));
667
 
        }
668
 
 
669
 
        //////////////////////////////////////
670
 
        // Binary bit operators
671
 
 
672
 
        template <typename T>
673
 
        GLM_FUNC_QUALIFIER tvec1<T> operator% 
674
 
        (
675
 
                tvec1<T> const & v, 
676
 
                typename tvec1<T>::value_type const & s
677
 
        )
678
 
        {
679
 
                return tvec1<T>(
680
 
                        v.x % s);
681
 
        }
682
 
 
683
 
        template <typename T>
684
 
        GLM_FUNC_QUALIFIER tvec1<T> operator% 
685
 
        (
686
 
                typename tvec1<T>::value_type const & s, 
687
 
                tvec1<T> const & v
688
 
        )
689
 
        {
690
 
                return tvec1<T>(
691
 
                        s % v.x);
692
 
        }
693
 
 
694
 
        template <typename T>
695
 
        GLM_FUNC_QUALIFIER tvec1<T> operator% 
696
 
        (
697
 
                tvec1<T> const & v1, 
698
 
                tvec1<T> const & v2
699
 
        )
700
 
        {
701
 
                return tvec1<T>(
702
 
                        v1.x % v2.x);
703
 
        }
704
 
 
705
 
        template <typename T>
706
 
        GLM_FUNC_QUALIFIER tvec1<T> operator& 
707
 
        (
708
 
                tvec1<T> const & v, 
709
 
                typename tvec1<T>::value_type const & s
710
 
        )
711
 
        {
712
 
                return tvec1<T>(
713
 
                        v.x & s);
714
 
        }
715
 
 
716
 
        template <typename T>
717
 
        GLM_FUNC_QUALIFIER tvec1<T> operator& 
718
 
        (
719
 
                typename tvec1<T>::value_type const & s, 
720
 
                tvec1<T> const & v
721
 
        )
722
 
        {
723
 
                return tvec1<T>(
724
 
                        s & v.x);
725
 
        }
726
 
 
727
 
        template <typename T>
728
 
        GLM_FUNC_QUALIFIER tvec1<T> operator& 
729
 
        (
730
 
                tvec1<T> const & v1, 
731
 
                tvec1<T> const & v2
732
 
        )
733
 
        {
734
 
                return tvec1<T>(
735
 
                        v1.x & v2.x);
736
 
        }
737
 
 
738
 
        template <typename T>
739
 
        GLM_FUNC_QUALIFIER tvec1<T> operator| 
740
 
        (
741
 
                tvec1<T> const & v, 
742
 
                typename tvec1<T>::value_type const & s
743
 
        )
744
 
        {
745
 
                return tvec1<T>(
746
 
                        v.x | s);
747
 
        }
748
 
 
749
 
        template <typename T>
750
 
        GLM_FUNC_QUALIFIER tvec1<T> operator| 
751
 
        (
752
 
                typename tvec1<T>::value_type const & s, 
753
 
                tvec1<T> const & v
754
 
        )
755
 
        {
756
 
                return tvec1<T>(
757
 
                        s | v.x);
758
 
        }
759
 
 
760
 
        template <typename T>
761
 
        GLM_FUNC_QUALIFIER tvec1<T> operator| 
762
 
        (
763
 
                tvec1<T> const & v1, 
764
 
                tvec1<T> const & v2
765
 
        )
766
 
        {
767
 
                return tvec1<T>(
768
 
                        v1.x | v2.x);
769
 
        }
770
 
                
771
 
        template <typename T>
772
 
        GLM_FUNC_QUALIFIER tvec1<T> operator^ 
773
 
        (
774
 
                tvec1<T> const & v, 
775
 
                typename tvec1<T>::value_type const & s
776
 
        )
777
 
        {
778
 
                return tvec1<T>(
779
 
                        v.x ^ s);
780
 
        }
781
 
 
782
 
        template <typename T>
783
 
        GLM_FUNC_QUALIFIER tvec1<T> operator^ 
784
 
        (
785
 
                typename tvec1<T>::value_type const & s, 
786
 
                tvec1<T> const & v
787
 
        )
788
 
        {
789
 
                return tvec1<T>(
790
 
                        s ^ v.x);
791
 
        }
792
 
 
793
 
        template <typename T>
794
 
        GLM_FUNC_QUALIFIER tvec1<T> operator^ 
795
 
        (
796
 
                tvec1<T> const & v1, 
797
 
                tvec1<T> const & v2
798
 
        )
799
 
        {
800
 
                return tvec1<T>(
801
 
                        v1.x ^ v2.x);
802
 
        }
803
 
 
804
 
        template <typename T>
805
 
        GLM_FUNC_QUALIFIER tvec1<T> operator<< 
806
 
        (
807
 
                tvec1<T> const & v, 
808
 
                typename tvec1<T>::value_type const & s
809
 
        )
810
 
        {
811
 
                return tvec1<T>(
812
 
                        v.x << s);
813
 
        }
814
 
 
815
 
        template <typename T>
816
 
        GLM_FUNC_QUALIFIER tvec1<T> operator<< 
817
 
        (
818
 
                typename tvec1<T>::value_type const & s, 
819
 
                tvec1<T> const & v
820
 
        )
821
 
        {
822
 
                return tvec1<T>(
823
 
                        s << v.x);
824
 
        }
825
 
 
826
 
        template <typename T>
827
 
        GLM_FUNC_QUALIFIER tvec1<T> operator<< 
828
 
        (
829
 
                tvec1<T> const & v1, 
830
 
                tvec1<T> const & v2
831
 
        )
832
 
        {
833
 
                return tvec1<T>(
834
 
                        v1.x << v2.x);
835
 
        }
836
 
 
837
 
        template <typename T>
838
 
        GLM_FUNC_QUALIFIER tvec1<T> operator>> 
839
 
        (
840
 
                tvec1<T> const & v, 
841
 
                typename tvec1<T>::value_type const & s
842
 
        )
843
 
        {
844
 
                return tvec1<T>(
845
 
                        v.x >> s);
846
 
        }
847
 
 
848
 
        template <typename T>
849
 
        GLM_FUNC_QUALIFIER tvec1<T> operator>> 
850
 
        (
851
 
                typename tvec1<T>::value_type const & s, 
852
 
                tvec1<T> const & v
853
 
        )
854
 
        {
855
 
                return tvec1<T>(
856
 
                        s >> v.x);
857
 
        }
858
 
 
859
 
        template <typename T>
860
 
        GLM_FUNC_QUALIFIER tvec1<T> operator>> 
861
 
        (
862
 
                tvec1<T> const & v1, 
863
 
                tvec1<T> const & v2
864
 
        )
865
 
        {
866
 
                return tvec1<T>(
867
 
                        v1.x >> v2.x);
868
 
        }
869
 
 
870
 
        template <typename T> 
871
 
        GLM_FUNC_QUALIFIER tvec1<T> operator~ 
872
 
        (
873
 
                tvec1<T> const & v
874
 
        )
875
 
        {
876
 
                return tvec1<T>(
877
 
                        ~v.x);
878
 
        }
879
 
 
880
 
        //////////////////////////////////////
881
 
        // tref definition
882
 
 
883
 
        template <typename T> 
884
 
        GLM_FUNC_QUALIFIER tref1<T>::tref1
885
 
        (
886
 
                T & x
887
 
        ) :
888
 
                x(x)
889
 
        {}
890
 
 
891
 
        template <typename T> 
892
 
        GLM_FUNC_QUALIFIER tref1<T>::tref1
893
 
        (
894
 
                tref1<T> const & r
895
 
        ) :
896
 
                x(r.x)
897
 
        {}
898
 
 
899
 
        template <typename T> 
900
 
        GLM_FUNC_QUALIFIER tref1<T>::tref1
901
 
        (
902
 
                tvec1<T> const & v
903
 
        ) :
904
 
                x(v.x)
905
 
        {}
906
 
 
907
 
        template <typename T> 
908
 
        GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator= 
909
 
        (
910
 
                tref1<T> const & r
911
 
        )
912
 
        {
913
 
                x = r.x;
914
 
                return *this;
915
 
        }
916
 
 
917
 
        template <typename T> 
918
 
        GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator= 
919
 
        (
920
 
                tvec1<T> const & v
921
 
        )
922
 
        {
923
 
                x = v.x;
924
 
                return *this;
925
 
        }
926
 
 
927
 
}//namespace detail
928
 
}//namespace glm