1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.renderscript;
18
19/**
20 * Vector version of the basic long type.
21 * Provides four long fields packed.
22 */
23public class Long4 {
24    public long x;
25    public long y;
26    public long z;
27    public long w;
28
29    public Long4() {
30    }
31
32    /** @hide */
33    public Long4(long i) {
34        this.x = this.y = this.z = this.w = i;
35    }
36
37    public Long4(long x, long y, long z, long w) {
38        this.x = x;
39        this.y = y;
40        this.z = z;
41        this.w = w;
42    }
43
44    /** @hide */
45    public Long4(Long4 source) {
46        this.x = source.x;
47        this.y = source.y;
48        this.z = source.z;
49        this.w = source.w;
50    }
51
52    /** @hide
53     * Vector add
54     *
55     * @param a
56     */
57    public void add(Long4 a) {
58        this.x += a.x;
59        this.y += a.y;
60        this.z += a.z;
61        this.w += a.w;
62    }
63
64    /** @hide
65     * Vector add
66     *
67     * @param a
68     * @param b
69     * @return
70     */
71    public static Long4 add(Long4 a, Long4 b) {
72        Long4 result = new Long4();
73        result.x = a.x + b.x;
74        result.y = a.y + b.y;
75        result.z = a.z + b.z;
76        result.w = a.w + b.w;
77
78        return result;
79    }
80
81    /** @hide
82     * Vector add
83     *
84     * @param value
85     */
86    public void add(long value) {
87        x += value;
88        y += value;
89        z += value;
90        w += value;
91    }
92
93    /** @hide
94     * Vector add
95     *
96     * @param a
97     * @param b
98     * @return
99     */
100    public static Long4 add(Long4 a, long b) {
101        Long4 result = new Long4();
102        result.x = a.x + b;
103        result.y = a.y + b;
104        result.z = a.z + b;
105        result.w = a.w + b;
106
107        return result;
108    }
109
110    /** @hide
111     * Vector subtraction
112     *
113     * @param a
114     */
115    public void sub(Long4 a) {
116        this.x -= a.x;
117        this.y -= a.y;
118        this.z -= a.z;
119        this.w -= a.w;
120    }
121
122    /** @hide
123     * Vector subtraction
124     *
125     * @param a
126     * @param b
127     * @return
128     */
129    public static Long4 sub(Long4 a, Long4 b) {
130        Long4 result = new Long4();
131        result.x = a.x - b.x;
132        result.y = a.y - b.y;
133        result.z = a.z - b.z;
134        result.w = a.w - b.w;
135
136        return result;
137    }
138
139    /** @hide
140     * Vector subtraction
141     *
142     * @param value
143     */
144    public void sub(long value) {
145        x -= value;
146        y -= value;
147        z -= value;
148        w -= value;
149    }
150
151    /** @hide
152     * Vector subtraction
153     *
154     * @param a
155     * @param b
156     * @return
157     */
158    public static Long4 sub(Long4 a, long b) {
159        Long4 result = new Long4();
160        result.x = a.x - b;
161        result.y = a.y - b;
162        result.z = a.z - b;
163        result.w = a.w - b;
164
165        return result;
166    }
167
168    /** @hide
169     * Vector multiplication
170     *
171     * @param a
172     */
173    public void mul(Long4 a) {
174        this.x *= a.x;
175        this.y *= a.y;
176        this.z *= a.z;
177        this.w *= a.w;
178    }
179
180    /** @hide
181     * Vector multiplication
182     *
183     * @param a
184     * @param b
185     * @return
186     */
187    public static Long4 mul(Long4 a, Long4 b) {
188        Long4 result = new Long4();
189        result.x = a.x * b.x;
190        result.y = a.y * b.y;
191        result.z = a.z * b.z;
192        result.w = a.w * b.w;
193
194        return result;
195    }
196
197    /** @hide
198     * Vector multiplication
199     *
200     * @param value
201     */
202    public void mul(long value) {
203        x *= value;
204        y *= value;
205        z *= value;
206        w *= value;
207    }
208
209    /** @hide
210     * Vector multiplication
211     *
212     * @param a
213     * @param b
214     * @return
215     */
216    public static Long4 mul(Long4 a, long b) {
217        Long4 result = new Long4();
218        result.x = a.x * b;
219        result.y = a.y * b;
220        result.z = a.z * b;
221        result.w = a.w * b;
222
223        return result;
224    }
225
226    /** @hide
227     * Vector division
228     *
229     * @param a
230     */
231    public void div(Long4 a) {
232        this.x /= a.x;
233        this.y /= a.y;
234        this.z /= a.z;
235        this.w /= a.w;
236    }
237
238    /** @hide
239     * Vector division
240     *
241     * @param a
242     * @param b
243     * @return
244     */
245    public static Long4 div(Long4 a, Long4 b) {
246        Long4 result = new Long4();
247        result.x = a.x / b.x;
248        result.y = a.y / b.y;
249        result.z = a.z / b.z;
250        result.w = a.w / b.w;
251
252        return result;
253    }
254
255    /** @hide
256     * Vector division
257     *
258     * @param value
259     */
260    public void div(long value) {
261        x /= value;
262        y /= value;
263        z /= value;
264        w /= value;
265    }
266
267    /** @hide
268     * Vector division
269     *
270     * @param a
271     * @param b
272     * @return
273     */
274    public static Long4 div(Long4 a, long b) {
275        Long4 result = new Long4();
276        result.x = a.x / b;
277        result.y = a.y / b;
278        result.z = a.z / b;
279        result.w = a.w / b;
280
281        return result;
282    }
283
284    /** @hide
285     * Vector Modulo
286     *
287     * @param a
288     */
289    public void mod(Long4 a) {
290        this.x %= a.x;
291        this.y %= a.y;
292        this.z %= a.z;
293        this.w %= a.w;
294    }
295
296    /** @hide
297     * Vector Modulo
298     *
299     * @param a
300     * @param b
301     * @return
302     */
303    public static Long4 mod(Long4 a, Long4 b) {
304        Long4 result = new Long4();
305        result.x = a.x % b.x;
306        result.y = a.y % b.y;
307        result.z = a.z % b.z;
308        result.w = a.w % b.w;
309
310        return result;
311    }
312
313    /** @hide
314     * Vector Modulo
315     *
316     * @param value
317     */
318    public void mod(long value) {
319        x %= value;
320        y %= value;
321        z %= value;
322        w %= value;
323    }
324
325    /** @hide
326     * Vector Modulo
327     *
328     * @param a
329     * @param b
330     * @return
331     */
332    public static Long4 mod(Long4 a, long b) {
333        Long4 result = new Long4();
334        result.x = a.x % b;
335        result.y = a.y % b;
336        result.z = a.z % b;
337        result.w = a.w % b;
338
339        return result;
340    }
341
342    /** @hide
343     * get vector length
344     *
345     * @return
346     */
347    public long length() {
348        return 4;
349    }
350
351    /** @hide
352     * set vector negate
353     */
354    public void negate() {
355        this.x = -x;
356        this.y = -y;
357        this.z = -z;
358        this.w = -w;
359    }
360
361    /** @hide
362     * Vector dot Product
363     *
364     * @param a
365     * @return
366     */
367    public long dotProduct(Long4 a) {
368        return (long)((x * a.x) + (y * a.y) + (z * a.z) + (w * a.w));
369    }
370
371    /** @hide
372     * Vector dot Product
373     *
374     * @param a
375     * @param b
376     * @return
377     */
378    public static long dotProduct(Long4 a, Long4 b) {
379        return (long)((b.x * a.x) + (b.y * a.y) + (b.z * a.z) + (b.w * a.w));
380    }
381
382    /** @hide
383     * Vector add Multiple
384     *
385     * @param a
386     * @param factor
387     */
388    public void addMultiple(Long4 a, long factor) {
389        x += a.x * factor;
390        y += a.y * factor;
391        z += a.z * factor;
392        w += a.w * factor;
393    }
394
395    /** @hide
396     * set vector value by Long4
397     *
398     * @param a
399     */
400    public void set(Long4 a) {
401        this.x = a.x;
402        this.y = a.y;
403        this.z = a.z;
404        this.w = a.w;
405    }
406
407    /** @hide
408     * set the vector field value by Long
409     *
410     * @param a
411     * @param b
412     * @param c
413     * @param d
414     */
415    public void setValues(long a, long b, long c, long d) {
416        this.x = a;
417        this.y = b;
418        this.z = c;
419        this.w = d;
420    }
421
422    /** @hide
423     * return the element sum of vector
424     *
425     * @return
426     */
427    public long elementSum() {
428        return (long)(x + y + z + w);
429    }
430
431    /** @hide
432     * get the vector field value by index
433     *
434     * @param i
435     * @return
436     */
437    public long get(int i) {
438        switch (i) {
439        case 0:
440            return (long)(x);
441        case 1:
442            return (long)(y);
443        case 2:
444            return (long)(z);
445        case 3:
446            return (long)(w);
447        default:
448            throw new IndexOutOfBoundsException("Index: i");
449        }
450    }
451
452    /** @hide
453     * set the vector field value by index
454     *
455     * @param i
456     * @param value
457     */
458    public void setAt(int i, long value) {
459        switch (i) {
460        case 0:
461            x = value;
462            return;
463        case 1:
464            y = value;
465            return;
466        case 2:
467            z = value;
468            return;
469        case 3:
470            w = value;
471            return;
472        default:
473            throw new IndexOutOfBoundsException("Index: i");
474        }
475    }
476
477    /** @hide
478     * add the vector field value by index
479     *
480     * @param i
481     * @param value
482     */
483    public void addAt(int i, long value) {
484        switch (i) {
485        case 0:
486            x += value;
487            return;
488        case 1:
489            y += value;
490            return;
491        case 2:
492            z += value;
493            return;
494        case 3:
495            w += value;
496            return;
497        default:
498            throw new IndexOutOfBoundsException("Index: i");
499        }
500    }
501
502    /** @hide
503     * copy the vector to long array
504     *
505     * @param data
506     * @param offset
507     */
508    public void copyTo(long[] data, int offset) {
509        data[offset] = (long)(x);
510        data[offset + 1] = (long)(y);
511        data[offset + 2] = (long)(z);
512        data[offset + 3] = (long)(w);
513    }
514}
515