← 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/gtx/simd_mat4.inl

Merged trunk and fixed issues

Show diffs side-by-side

added added

removed removed

Lines of Context:
3rd_party/glm/glm/gtx/simd_mat4.inl
1
 
///////////////////////////////////////////////////////////////////////////////////////////////////
2
 
// OpenGL Mathematics Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
3
 
///////////////////////////////////////////////////////////////////////////////////////////////////
4
 
// Created : 2009-05-19
5
 
// Updated : 2009-05-19
6
 
// Licence : This source is under MIT License
7
 
// File    : glm/gtx/simd_mat4.hpp
8
 
///////////////////////////////////////////////////////////////////////////////////////////////////
9
 
 
10
 
namespace glm{
11
 
namespace detail{
12
 
 
13
 
GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::value_size()
14
 
{
15
 
        return sizeof(value_type);
16
 
}
17
 
 
18
 
GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::col_size()
19
 
{
20
 
        return 4;
21
 
}
22
 
 
23
 
GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::row_size()
24
 
{
25
 
        return 4;
26
 
}
27
 
 
28
 
GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD()
29
 
{}
30
 
 
31
 
GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD(float const & s)
32
 
{
33
 
        this->Data[0] = fvec4SIMD(s, 0, 0, 0);
34
 
        this->Data[1] = fvec4SIMD(0, s, 0, 0);
35
 
        this->Data[2] = fvec4SIMD(0, 0, s, 0);
36
 
        this->Data[3] = fvec4SIMD(0, 0, 0, s);
37
 
}
38
 
 
39
 
GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
40
 
(
41
 
        float const & x0, float const & y0, float const & z0, float const & w0,
42
 
        float const & x1, float const & y1, float const & z1, float const & w1,
43
 
        float const & x2, float const & y2, float const & z2, float const & w2,
44
 
        float const & x3, float const & y3, float const & z3, float const & w3
45
 
)
46
 
{
47
 
        this->Data[0] = fvec4SIMD(x0, y0, z0, w0);
48
 
        this->Data[1] = fvec4SIMD(x1, y1, z1, w1);
49
 
        this->Data[2] = fvec4SIMD(x2, y2, z2, w2);
50
 
        this->Data[3] = fvec4SIMD(x3, y3, z3, w3);
51
 
}
52
 
 
53
 
GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
54
 
(
55
 
        fvec4SIMD const & v0,
56
 
        fvec4SIMD const & v1,
57
 
        fvec4SIMD const & v2,
58
 
        fvec4SIMD const & v3
59
 
)
60
 
{
61
 
        this->Data[0] = v0;
62
 
        this->Data[1] = v1;
63
 
        this->Data[2] = v2;
64
 
        this->Data[3] = v3;
65
 
}
66
 
 
67
 
GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
68
 
(
69
 
        tmat4x4<float> const & m
70
 
)
71
 
{
72
 
        this->Data[0] = fvec4SIMD(m[0]);
73
 
        this->Data[1] = fvec4SIMD(m[1]);
74
 
        this->Data[2] = fvec4SIMD(m[2]);
75
 
        this->Data[3] = fvec4SIMD(m[3]);
76
 
}
77
 
 
78
 
//////////////////////////////////////
79
 
// Accesses
80
 
 
81
 
GLM_FUNC_QUALIFIER fvec4SIMD & fmat4x4SIMD::operator[]
82
 
(
83
 
        fmat4x4SIMD::size_type i
84
 
)
85
 
{
86
 
        assert(
87
 
                i >= fmat4x4SIMD::size_type(0) &&
88
 
                i < fmat4x4SIMD::col_size());
89
 
 
90
 
        return this->Data[i];
91
 
}
92
 
 
93
 
GLM_FUNC_QUALIFIER fvec4SIMD const & fmat4x4SIMD::operator[]
94
 
(
95
 
        fmat4x4SIMD::size_type i
96
 
) const
97
 
{
98
 
        assert(
99
 
                i >= fmat4x4SIMD::size_type(0) &&
100
 
                i < fmat4x4SIMD::col_size());
101
 
 
102
 
        return this->Data[i];
103
 
}
104
 
 
105
 
//////////////////////////////////////////////////////////////
106
 
// mat4 operators
107
 
 
108
 
GLM_FUNC_QUALIFIER fmat4x4SIMD& fmat4x4SIMD::operator= 
109
 
(
110
 
        fmat4x4SIMD const & m
111
 
)
112
 
{
113
 
        this->Data[0] = m[0];
114
 
        this->Data[1] = m[1];
115
 
        this->Data[2] = m[2];
116
 
        this->Data[3] = m[3];
117
 
    return *this;
118
 
}
119
 
 
120
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator+= 
121
 
(
122
 
        fmat4x4SIMD const & m
123
 
)
124
 
{
125
 
        this->Data[0].Data = _mm_add_ps(this->Data[0].Data, m[0].Data);
126
 
        this->Data[1].Data = _mm_add_ps(this->Data[1].Data, m[1].Data);
127
 
        this->Data[2].Data = _mm_add_ps(this->Data[2].Data, m[2].Data);
128
 
        this->Data[3].Data = _mm_add_ps(this->Data[3].Data, m[3].Data);
129
 
    return *this;
130
 
}
131
 
 
132
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-= 
133
 
(
134
 
        fmat4x4SIMD const & m
135
 
)
136
 
{
137
 
        this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, m[0].Data);
138
 
        this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, m[1].Data);
139
 
        this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, m[2].Data);
140
 
        this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, m[3].Data);
141
 
 
142
 
    return *this;
143
 
}
144
 
 
145
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator*= 
146
 
(
147
 
        fmat4x4SIMD const & m
148
 
)
149
 
{
150
 
        sse_mul_ps(&this->Data[0].Data, &m.Data[0].Data, &this->Data[0].Data);
151
 
    return *this;
152
 
}
153
 
 
154
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator/= 
155
 
(
156
 
        fmat4x4SIMD const & m
157
 
)
158
 
{
159
 
        __m128 Inv[4];
160
 
        sse_inverse_ps(&m.Data[0].Data, Inv);
161
 
        sse_mul_ps(&this->Data[0].Data, Inv, &this->Data[0].Data);
162
 
    return *this;
163
 
}
164
 
 
165
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator+= 
166
 
(
167
 
        float const & s
168
 
)
169
 
{
170
 
        __m128 Operand = _mm_set_ps1(s);
171
 
        this->Data[0].Data = _mm_add_ps(this->Data[0].Data, Operand);
172
 
        this->Data[1].Data = _mm_add_ps(this->Data[1].Data, Operand);
173
 
        this->Data[2].Data = _mm_add_ps(this->Data[2].Data, Operand);
174
 
        this->Data[3].Data = _mm_add_ps(this->Data[3].Data, Operand);
175
 
    return *this;
176
 
}
177
 
 
178
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-= 
179
 
(
180
 
        float const & s
181
 
)
182
 
{
183
 
        __m128 Operand = _mm_set_ps1(s);
184
 
        this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, Operand);
185
 
        this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, Operand);
186
 
        this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, Operand);
187
 
        this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, Operand);
188
 
    return *this;
189
 
}
190
 
 
191
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator*= 
192
 
(
193
 
        float const & s
194
 
)
195
 
{
196
 
        __m128 Operand = _mm_set_ps1(s);
197
 
        this->Data[0].Data = _mm_mul_ps(this->Data[0].Data, Operand);
198
 
        this->Data[1].Data = _mm_mul_ps(this->Data[1].Data, Operand);
199
 
        this->Data[2].Data = _mm_mul_ps(this->Data[2].Data, Operand);
200
 
        this->Data[3].Data = _mm_mul_ps(this->Data[3].Data, Operand);
201
 
    return *this;
202
 
}
203
 
 
204
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator/= 
205
 
(
206
 
        float const & s
207
 
)
208
 
{
209
 
        __m128 Operand = _mm_div_ps(one, _mm_set_ps1(s));
210
 
        this->Data[0].Data = _mm_mul_ps(this->Data[0].Data, Operand);
211
 
        this->Data[1].Data = _mm_mul_ps(this->Data[1].Data, Operand);
212
 
        this->Data[2].Data = _mm_mul_ps(this->Data[2].Data, Operand);
213
 
        this->Data[3].Data = _mm_mul_ps(this->Data[3].Data, Operand);
214
 
    return *this;
215
 
}
216
 
 
217
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator++ ()
218
 
{
219
 
        this->Data[0].Data = _mm_add_ps(this->Data[0].Data, one);
220
 
        this->Data[1].Data = _mm_add_ps(this->Data[1].Data, one);
221
 
        this->Data[2].Data = _mm_add_ps(this->Data[2].Data, one);
222
 
        this->Data[3].Data = _mm_add_ps(this->Data[3].Data, one);
223
 
    return *this;
224
 
}
225
 
 
226
 
GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-- ()
227
 
{
228
 
        this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, one);
229
 
        this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, one);
230
 
        this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, one);
231
 
        this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, one);
232
 
    return *this;
233
 
}
234
 
 
235
 
}//namespace detail
236
 
 
237
 
GLM_FUNC_QUALIFIER detail::tmat4x4<float> mat4_cast
238
 
(
239
 
        detail::fmat4x4SIMD const & x
240
 
)
241
 
{
242
 
        GLM_ALIGN(16) detail::tmat4x4<float> Result;
243
 
        _mm_store_ps(&Result[0][0], x.Data[0].Data);
244
 
        _mm_store_ps(&Result[1][0], x.Data[1].Data);
245
 
        _mm_store_ps(&Result[2][0], x.Data[2].Data);
246
 
        _mm_store_ps(&Result[3][0], x.Data[3].Data);
247
 
        return Result;
248
 
}
249
 
 
250
 
GLM_FUNC_QUALIFIER detail::fmat4x4SIMD matrixCompMult
251
 
(
252
 
        detail::fmat4x4SIMD const & x,
253
 
        detail::fmat4x4SIMD const & y
254
 
)
255
 
{
256
 
        detail::fmat4x4SIMD result;
257
 
        result[0] = x[0] * y[0];
258
 
        result[1] = x[1] * y[1];
259
 
        result[2] = x[2] * y[2];
260
 
        result[3] = x[3] * y[3];
261
 
        return result;
262
 
}
263
 
 
264
 
GLM_FUNC_QUALIFIER detail::fmat4x4SIMD outerProduct
265
 
(
266
 
        detail::fvec4SIMD const & c,
267
 
        detail::fvec4SIMD const & r
268
 
)
269
 
{
270
 
        __m128 Shu0 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(0, 0, 0, 0));
271
 
        __m128 Shu1 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(1, 1, 1, 1));
272
 
        __m128 Shu2 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(2, 2, 2, 2));
273
 
        __m128 Shu3 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(3, 3, 3, 3));
274
 
 
275
 
        detail::fmat4x4SIMD result(detail::fmat4x4SIMD::null);
276
 
        result[0].Data = _mm_mul_ps(c.Data, Shu0);
277
 
        result[1].Data = _mm_mul_ps(c.Data, Shu1);
278
 
        result[2].Data = _mm_mul_ps(c.Data, Shu2);
279
 
        result[3].Data = _mm_mul_ps(c.Data, Shu3);
280
 
        return result;
281
 
}
282
 
 
283
 
GLM_FUNC_QUALIFIER detail::fmat4x4SIMD transpose(detail::fmat4x4SIMD const & m)
284
 
{
285
 
        detail::fmat4x4SIMD result;
286
 
        detail::sse_transpose_ps(&m[0].Data, &result[0].Data);
287
 
        return result;
288
 
}
289
 
 
290
 
GLM_FUNC_QUALIFIER float determinant(detail::fmat4x4SIMD const & m)
291
 
{
292
 
        float Result;
293
 
        _mm_store_ss(&Result, detail::sse_det_ps(&m[0].Data));
294
 
        return Result;
295
 
}
296
 
 
297
 
GLM_FUNC_QUALIFIER detail::fmat4x4SIMD inverse(detail::fmat4x4SIMD const & m)
298
 
{
299
 
        detail::fmat4x4SIMD result;
300
 
        detail::sse_inverse_ps(&m[0].Data, &result[0].Data);
301
 
        return result;
302
 
}
303
 
 
304
 
}//namespace glm