1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// swizzle characters: ['x', 'y', 'z']
use super::*;
impl Vec3 {
  /// Swizzle: obtains the `xx` combination
  pub fn xx(self) -> Vec2 {
    self.v4.xx()
  }
  /// Swizzle: obtains the `xxx` combination
  pub fn xxx(self) -> Self {
    self.v4.xxx()
  }
  /// Swizzle: obtains the `xxy` combination
  pub fn xxy(self) -> Self {
    self.v4.xxy()
  }
  /// Swizzle: obtains the `xxz` combination
  pub fn xxz(self) -> Self {
    self.v4.xxz()
  }
  /// Swizzle: obtains the `xy` combination
  pub fn xy(self) -> Vec2 {
    self.v4.xy()
  }
  /// Swizzle: obtains the `xyx` combination
  pub fn xyx(self) -> Self {
    self.v4.xyx()
  }
  /// Swizzle: obtains the `xyy` combination
  pub fn xyy(self) -> Self {
    self.v4.xyy()
  }
  /// Swizzle: obtains the `xyz` combination
  pub fn xyz(self) -> Self {
    self.v4.xyz()
  }
  /// Swizzle: obtains the `xz` combination
  pub fn xz(self) -> Vec2 {
    self.v4.xz()
  }
  /// Swizzle: obtains the `xzx` combination
  pub fn xzx(self) -> Self {
    self.v4.xzx()
  }
  /// Swizzle: obtains the `xzy` combination
  pub fn xzy(self) -> Self {
    self.v4.xzy()
  }
  /// Swizzle: obtains the `xzz` combination
  pub fn xzz(self) -> Self {
    self.v4.xzz()
  }
  /// Swizzle: obtains the `yx` combination
  pub fn yx(self) -> Vec2 {
    self.v4.yx()
  }
  /// Swizzle: obtains the `yxx` combination
  pub fn yxx(self) -> Self {
    self.v4.yxx()
  }
  /// Swizzle: obtains the `yxy` combination
  pub fn yxy(self) -> Self {
    self.v4.yxy()
  }
  /// Swizzle: obtains the `yxz` combination
  pub fn yxz(self) -> Self {
    self.v4.yxz()
  }
  /// Swizzle: obtains the `yy` combination
  pub fn yy(self) -> Vec2 {
    self.v4.yy()
  }
  /// Swizzle: obtains the `yyx` combination
  pub fn yyx(self) -> Self {
    self.v4.yyx()
  }
  /// Swizzle: obtains the `yyy` combination
  pub fn yyy(self) -> Self {
    self.v4.yyy()
  }
  /// Swizzle: obtains the `yyz` combination
  pub fn yyz(self) -> Self {
    self.v4.yyz()
  }
  /// Swizzle: obtains the `yz` combination
  pub fn yz(self) -> Vec2 {
    self.v4.yz()
  }
  /// Swizzle: obtains the `yzx` combination
  pub fn yzx(self) -> Self {
    self.v4.yzx()
  }
  /// Swizzle: obtains the `yzy` combination
  pub fn yzy(self) -> Self {
    self.v4.yzy()
  }
  /// Swizzle: obtains the `yzz` combination
  pub fn yzz(self) -> Self {
    self.v4.yzz()
  }
  /// Swizzle: obtains the `zx` combination
  pub fn zx(self) -> Vec2 {
    self.v4.zx()
  }
  /// Swizzle: obtains the `zxx` combination
  pub fn zxx(self) -> Self {
    self.v4.zxx()
  }
  /// Swizzle: obtains the `zxy` combination
  pub fn zxy(self) -> Self {
    self.v4.zxy()
  }
  /// Swizzle: obtains the `zxz` combination
  pub fn zxz(self) -> Self {
    self.v4.zxz()
  }
  /// Swizzle: obtains the `zy` combination
  pub fn zy(self) -> Vec2 {
    self.v4.zy()
  }
  /// Swizzle: obtains the `zyx` combination
  pub fn zyx(self) -> Self {
    self.v4.zyx()
  }
  /// Swizzle: obtains the `zyy` combination
  pub fn zyy(self) -> Self {
    self.v4.zyy()
  }
  /// Swizzle: obtains the `zyz` combination
  pub fn zyz(self) -> Self {
    self.v4.zyz()
  }
  /// Swizzle: obtains the `zz` combination
  pub fn zz(self) -> Vec2 {
    self.v4.zz()
  }
  /// Swizzle: obtains the `zzx` combination
  pub fn zzx(self) -> Self {
    self.v4.zzx()
  }
  /// Swizzle: obtains the `zzy` combination
  pub fn zzy(self) -> Self {
    self.v4.zzy()
  }
  /// Swizzle: obtains the `zzz` combination
  pub fn zzz(self) -> Self {
    self.v4.zzz()
  }
}