/rs/java/android/renderscript/Int4.java

  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 int type.
 21 * Provides four int fields packed.
 22 */
 23public class Int4 {
 24    public int x;
 25    public int y;
 26    public int z;
 27    public int w;
 28
 29    public Int4() {
 30    }
 31
 32    /** @hide */
 33    public Int4(int i) {
 34        this.x = this.y = this.z = this.w = i;
 35    }
 36
 37    public Int4(int x, int y, int z, int w) {
 38        this.x = x;
 39        this.y = y;
 40        this.z = z;
 41        this.w = w;
 42    }
 43
 44    /** @hide */
 45    public Int4(Int4 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(Int4 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 Int4 add(Int4 a, Int4 b) {
 72        Int4 result = new Int4();
 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(int 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 Int4 add(Int4 a, int b) {
101        Int4 result = new Int4();
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(Int4 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 Int4 sub(Int4 a, Int4 b) {
130        Int4 result = new Int4();
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(int 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 Int4 sub(Int4 a, int b) {
159        Int4 result = new Int4();
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(Int4 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 Int4 mul(Int4 a, Int4 b) {
188        Int4 result = new Int4();
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(int 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 Int4 mul(Int4 a, int b) {
217        Int4 result = new Int4();
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(Int4 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 Int4 div(Int4 a, Int4 b) {
246        Int4 result = new Int4();
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(int 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 Int4 div(Int4 a, int b) {
275        Int4 result = new Int4();
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(Int4 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 Int4 mod(Int4 a, Int4 b) {
304        Int4 result = new Int4();
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(int 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 Int4 mod(Int4 a, int b) {
333        Int4 result = new Int4();
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 int 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 int dotProduct(Int4 a) {
368        return (int)((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 int dotProduct(Int4 a, Int4 b) {
379        return (int)((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(Int4 a, int 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 Int4
397     *
398     * @param a
399     */
400    public void set(Int4 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 Int
409     *
410     * @param a
411     * @param b
412     * @param c
413     * @param d
414     */
415    public void setValues(int a, int b, int c, int 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 int elementSum() {
428        return (int)(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 int get(int i) {
438        switch (i) {
439        case 0:
440            return (int)(x);
441        case 1:
442            return (int)(y);
443        case 2:
444            return (int)(z);
445        case 3:
446            return (int)(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, int 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, int 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 int array
504     *
505     * @param data
506     * @param offset
507     */
508    public void copyTo(int[] data, int offset) {
509        data[offset] = (int)(x);
510        data[offset + 1] = (int)(y);
511        data[offset + 2] = (int)(z);
512        data[offset + 3] = (int)(w);
513    }
514}