/rs/java/android/renderscript/Float3.java

https://github.com/aizuzi/platform_frameworks_base · Java · 417 lines · 193 code · 40 blank · 184 comment · 3 complexity · 4acc3e34a4690cb7a0df9e5d88b8aa1d MD5 · raw file

  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. package android.renderscript;
  17. /**
  18. * Vector version of the basic float type.
  19. * Provides three float fields packed.
  20. */
  21. public class Float3 {
  22. public float x;
  23. public float y;
  24. public float z;
  25. public Float3() {
  26. }
  27. /** @hide */
  28. public Float3(Float3 data) {
  29. this.x = data.x;
  30. this.y = data.y;
  31. this.z = data.z;
  32. }
  33. public Float3(float x, float y, float z) {
  34. this.x = x;
  35. this.y = y;
  36. this.z = z;
  37. }
  38. /** @hide
  39. * Vector add
  40. *
  41. * @param a
  42. * @param b
  43. * @return
  44. */
  45. public static Float3 add(Float3 a, Float3 b) {
  46. Float3 res = new Float3();
  47. res.x = a.x + b.x;
  48. res.y = a.y + b.y;
  49. res.z = a.z + b.z;
  50. return res;
  51. }
  52. /** @hide
  53. * Vector add
  54. *
  55. * @param value
  56. */
  57. public void add(Float3 value) {
  58. x += value.x;
  59. y += value.y;
  60. z += value.z;
  61. }
  62. /** @hide
  63. * Vector add
  64. *
  65. * @param value
  66. */
  67. public void add(float value) {
  68. x += value;
  69. y += value;
  70. z += value;
  71. }
  72. /** @hide
  73. * Vector add
  74. *
  75. * @param a
  76. * @param b
  77. * @return
  78. */
  79. public static Float3 add(Float3 a, float b) {
  80. Float3 res = new Float3();
  81. res.x = a.x + b;
  82. res.y = a.y + b;
  83. res.z = a.z + b;
  84. return res;
  85. }
  86. /** @hide
  87. * Vector subtraction
  88. *
  89. * @param value
  90. */
  91. public void sub(Float3 value) {
  92. x -= value.x;
  93. y -= value.y;
  94. z -= value.z;
  95. }
  96. /** @hide
  97. * Vector subtraction
  98. *
  99. * @param a
  100. * @param b
  101. * @return
  102. */
  103. public static Float3 sub(Float3 a, Float3 b) {
  104. Float3 res = new Float3();
  105. res.x = a.x - b.x;
  106. res.y = a.y - b.y;
  107. res.z = a.z - b.z;
  108. return res;
  109. }
  110. /** @hide
  111. * Vector subtraction
  112. *
  113. * @param value
  114. */
  115. public void sub(float value) {
  116. x -= value;
  117. y -= value;
  118. z -= value;
  119. }
  120. /** @hide
  121. * Vector subtraction
  122. *
  123. * @param a
  124. * @param b
  125. * @return
  126. */
  127. public static Float3 sub(Float3 a, float b) {
  128. Float3 res = new Float3();
  129. res.x = a.x - b;
  130. res.y = a.y - b;
  131. res.z = a.z - b;
  132. return res;
  133. }
  134. /** @hide
  135. * Vector multiplication
  136. *
  137. * @param value
  138. */
  139. public void mul(Float3 value) {
  140. x *= value.x;
  141. y *= value.y;
  142. z *= value.z;
  143. }
  144. /** @hide
  145. * Vector multiplication
  146. *
  147. * @param a
  148. * @param b
  149. * @return
  150. */
  151. public static Float3 mul(Float3 a, Float3 b) {
  152. Float3 res = new Float3();
  153. res.x = a.x * b.x;
  154. res.y = a.y * b.y;
  155. res.z = a.z * b.z;
  156. return res;
  157. }
  158. /** @hide
  159. * Vector multiplication
  160. *
  161. * @param value
  162. */
  163. public void mul(float value) {
  164. x *= value;
  165. y *= value;
  166. z *= value;
  167. }
  168. /** @hide
  169. * Vector multiplication
  170. *
  171. * @param a
  172. * @param b
  173. * @return
  174. */
  175. public static Float3 mul(Float3 a, float b) {
  176. Float3 res = new Float3();
  177. res.x = a.x * b;
  178. res.y = a.y * b;
  179. res.z = a.z * b;
  180. return res;
  181. }
  182. /** @hide
  183. * Vector division
  184. *
  185. * @param value
  186. */
  187. public void div(Float3 value) {
  188. x /= value.x;
  189. y /= value.y;
  190. z /= value.z;
  191. }
  192. /** @hide
  193. * Vector division
  194. *
  195. * @param a
  196. * @param b
  197. * @return
  198. */
  199. public static Float3 div(Float3 a, Float3 b) {
  200. Float3 res = new Float3();
  201. res.x = a.x / b.x;
  202. res.y = a.y / b.y;
  203. res.z = a.z / b.z;
  204. return res;
  205. }
  206. /** @hide
  207. * Vector division
  208. *
  209. * @param value
  210. */
  211. public void div(float value) {
  212. x /= value;
  213. y /= value;
  214. z /= value;
  215. }
  216. /** @hide
  217. * Vector division
  218. *
  219. * @param a
  220. * @param b
  221. * @return
  222. */
  223. public static Float3 div(Float3 a, float b) {
  224. Float3 res = new Float3();
  225. res.x = a.x / b;
  226. res.y = a.y / b;
  227. res.z = a.z / b;
  228. return res;
  229. }
  230. /** @hide
  231. * Vector dot Product
  232. *
  233. * @param a
  234. * @return
  235. */
  236. public Float dotProduct(Float3 a) {
  237. return new Float((x * a.x) + (y * a.y) + (z * a.z));
  238. }
  239. /** @hide
  240. * Vector dot Product
  241. *
  242. * @param a
  243. * @param b
  244. * @return
  245. */
  246. public static Float dotProduct(Float3 a, Float3 b) {
  247. return new Float((b.x * a.x) + (b.y * a.y) + (b.z * a.z));
  248. }
  249. /** @hide
  250. * Vector add Multiple
  251. *
  252. * @param a
  253. * @param factor
  254. */
  255. public void addMultiple(Float3 a, float factor) {
  256. x += a.x * factor;
  257. y += a.y * factor;
  258. z += a.z * factor;
  259. }
  260. /** @hide
  261. * set vector value by float3
  262. *
  263. * @param a
  264. */
  265. public void set(Float3 a) {
  266. this.x = a.x;
  267. this.y = a.y;
  268. this.z = a.z;
  269. }
  270. /** @hide
  271. * set vector negate
  272. */
  273. public void negate() {
  274. x = -x;
  275. y = -y;
  276. z = -z;
  277. }
  278. /** @hide
  279. * get vector length
  280. *
  281. * @return
  282. */
  283. public int length() {
  284. return 3;
  285. }
  286. /** @hide
  287. * return the element sum of vector
  288. *
  289. * @return
  290. */
  291. public Float elementSum() {
  292. return new Float(x + y + z);
  293. }
  294. /** @hide
  295. * get the vector field value by index
  296. *
  297. * @param i
  298. * @return
  299. */
  300. public float get(int i) {
  301. switch (i) {
  302. case 0:
  303. return x;
  304. case 1:
  305. return y;
  306. case 2:
  307. return z;
  308. default:
  309. throw new IndexOutOfBoundsException("Index: i");
  310. }
  311. }
  312. /** @hide
  313. * set the vector field value by index
  314. *
  315. * @param i
  316. * @param value
  317. */
  318. public void setAt(int i, float value) {
  319. switch (i) {
  320. case 0:
  321. x = value;
  322. return;
  323. case 1:
  324. y = value;
  325. return;
  326. case 2:
  327. z = value;
  328. return;
  329. default:
  330. throw new IndexOutOfBoundsException("Index: i");
  331. }
  332. }
  333. /** @hide
  334. * add the vector field value by index
  335. *
  336. * @param i
  337. * @param value
  338. */
  339. public void addAt(int i, float value) {
  340. switch (i) {
  341. case 0:
  342. x += value;
  343. return;
  344. case 1:
  345. y += value;
  346. return;
  347. case 2:
  348. z += value;
  349. return;
  350. default:
  351. throw new IndexOutOfBoundsException("Index: i");
  352. }
  353. }
  354. /** @hide
  355. * set the vector field value
  356. *
  357. * @param x
  358. * @param y
  359. * @param z
  360. */
  361. public void setValues(float x, float y, float z) {
  362. this.x = x;
  363. this.y = y;
  364. this.z = z;
  365. }
  366. /** @hide
  367. * copy the vector to float array
  368. *
  369. * @param data
  370. * @param offset
  371. */
  372. public void copyTo(float[] data, int offset) {
  373. data[offset] = x;
  374. data[offset + 1] = y;
  375. data[offset + 2] = z;
  376. }
  377. }